mono_verifier_verify_pe_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.19267;
  gboolean D.19270;
  _Bool D.19271;
  int D.19272;
  int D.19273;
  struct VerifyContext ctx;
  void cleanup = <<< error >>>;

  try
    {
      D.19267 = mono_verifier_is_enabled_for_image (image);
      if (D.19267 == 0) goto <D.19268>; else goto <D.19269>;
      <D.19268>:
      D.19270 = 1;
      return D.19270;
      <D.19269>:
      D.19271 = error_list != 0B;
      D.19272 = (int) D.19271;
      init_verify_context (&ctx, image, D.19272);
      ctx.stage = 0;
      verify_msdos_header (&ctx);
      D.19273 = ctx.valid;
      if (D.19273 == 0) goto cleanup; else goto <D.19274>;
      <D.19274>:
      verify_pe_header (&ctx);
      D.19273 = ctx.valid;
      if (D.19273 == 0) goto cleanup; else goto <D.19275>;
      <D.19275>:
      verify_pe_optional_header (&ctx);
      D.19273 = ctx.valid;
      if (D.19273 == 0) goto cleanup; else goto <D.19276>;
      <D.19276>:
      load_section_table (&ctx);
      D.19273 = ctx.valid;
      if (D.19273 == 0) goto cleanup; else goto <D.19277>;
      <D.19277>:
      load_data_directories (&ctx);
      D.19273 = ctx.valid;
      if (D.19273 == 0) goto cleanup; else goto <D.19278>;
      <D.19278>:
      verify_import_table (&ctx);
      D.19273 = ctx.valid;
      if (D.19273 == 0) goto cleanup; else goto <D.19279>;
      <D.19279>:
      verify_resources_table (&ctx);
      cleanup:
      D.19270 = cleanup_context (&ctx, error_list);
      return D.19270;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


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

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.19286;
  int D.19291;
  void * D.19293;
  unsigned int D.19294;

  D.19286 = __builtin_constant_p (__len);
  if (D.19286 != 0) goto <D.19287>; else goto <D.19288>;
  <D.19287>:
  if (__len == 0) goto <D.19289>; else goto <D.19290>;
  <D.19289>:
  D.19291 = __builtin_constant_p (__ch);
  if (D.19291 == 0) goto <D.19284>; else goto <D.19292>;
  <D.19292>:
  if (__ch != 0) goto <D.19284>; else goto <D.19285>;
  <D.19284>:
  __warn_memset_zero_len ();
  D.19293 = __dest;
  return D.19293;
  <D.19285>:
  <D.19290>:
  <D.19288>:
  D.19294 = __builtin_object_size (__dest, 0);
  D.19293 = __builtin___memset_chk (__dest, __ch, __len, D.19294);
  return D.19293;
}


verify_msdos_header (struct VerifyContext * ctx)
{
  unsigned int D.19296;
  int D.19299;
  gchar * D.19302;
  struct GSList * D.19303;
  struct GSList * D.19304;
  const char * D.19307;
  char D.19308;
  const char * D.19310;
  char D.19311;
  gchar * D.19314;
  struct GSList * D.19315;
  unsigned int D.19316;
  gchar * D.19321;
  struct GSList * D.19322;
  guint32 lfanew;

  D.19296 = ctx->size;
  if (D.19296 <= 127) goto <D.19297>; else goto <D.19298>;
  <D.19297>:
  D.19299 = ctx->report_error;
  if (D.19299 != 0) goto <D.19300>; else goto <D.19301>;
  <D.19300>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19302 = monoeg_strdup ("Not enough space for the MS-DOS header");
    vinfo->info.message = D.19302;
    vinfo->exception_type = 3;
    D.19303 = ctx->errors;
    D.19304 = monoeg_g_slist_prepend (D.19303, vinfo);
    ctx->errors = D.19304;
  }
  <D.19301>:
  ctx->valid = 0;
  return;
  <D.19298>:
  D.19307 = ctx->data;
  D.19308 = *D.19307;
  if (D.19308 != 77) goto <D.19305>; else goto <D.19309>;
  <D.19309>:
  D.19307 = ctx->data;
  D.19310 = D.19307 + 1;
  D.19311 = *D.19310;
  if (D.19311 != 90) goto <D.19305>; else goto <D.19306>;
  <D.19305>:
  D.19299 = ctx->report_error;
  if (D.19299 != 0) goto <D.19312>; else goto <D.19313>;
  <D.19312>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19314 = monoeg_strdup ("Invalid MS-DOS watermark");
    vinfo->info.message = D.19314;
    vinfo->exception_type = 3;
    D.19303 = ctx->errors;
    D.19315 = monoeg_g_slist_prepend (D.19303, vinfo);
    ctx->errors = D.19315;
  }
  <D.19313>:
  ctx->valid = 0;
  return;
  <D.19306>:
  lfanew = pe_signature_offset (ctx);
  D.19296 = ctx->size;
  D.19316 = D.19296 + 4294967292;
  if (D.19316 < lfanew) goto <D.19317>; else goto <D.19318>;
  <D.19317>:
  D.19299 = ctx->report_error;
  if (D.19299 != 0) goto <D.19319>; else goto <D.19320>;
  <D.19319>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19321 = monoeg_strdup ("MS-DOS lfanew offset points to outside of the file");
    vinfo->info.message = D.19321;
    vinfo->exception_type = 3;
    D.19303 = ctx->errors;
    D.19322 = monoeg_g_slist_prepend (D.19303, vinfo);
    ctx->errors = D.19322;
  }
  <D.19320>:
  ctx->valid = 0;
  return;
  <D.19318>:
}


pe_signature_offset (struct VerifyContext * ctx)
{
  guint32 D.19324;
  const char * D.19325;
  const guint32 * D.19326;

  D.19325 = ctx->data;
  D.19326 = D.19325 + 60;
  D.19324 = *D.19326;
  return D.19324;
}


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

  if (str != 0B) goto <D.19328>; else goto <D.19329>;
  <D.19328>:
  D.19330 = __strdup (str);
  return D.19330;
  <D.19329>:
  D.19330 = 0B;
  return D.19330;
}


verify_pe_header (struct VerifyContext * ctx)
{
  const char * D.19332;
  char D.19335;
  const char * D.19337;
  char D.19338;
  const char * D.19340;
  char D.19341;
  const char * D.19343;
  char D.19344;
  int D.19345;
  gchar * D.19348;
  struct GSList * D.19349;
  struct GSList * D.19350;
  unsigned int D.19351;
  unsigned int D.19352;
  gchar * D.19357;
  struct GSList * D.19358;
  short unsigned int D.19359;
  gchar * D.19364;
  struct GSList * D.19365;
  guint32 offset;
  const char * pe_header;

  offset = pe_signature_offset (ctx);
  D.19332 = ctx->data;
  pe_header = D.19332 + offset;
  D.19335 = *pe_header;
  if (D.19335 != 80) goto <D.19333>; else goto <D.19336>;
  <D.19336>:
  D.19337 = pe_header + 1;
  D.19338 = *D.19337;
  if (D.19338 != 69) goto <D.19333>; else goto <D.19339>;
  <D.19339>:
  D.19340 = pe_header + 2;
  D.19341 = *D.19340;
  if (D.19341 != 0) goto <D.19333>; else goto <D.19342>;
  <D.19342>:
  D.19343 = pe_header + 3;
  D.19344 = *D.19343;
  if (D.19344 != 0) goto <D.19333>; else goto <D.19334>;
  <D.19333>:
  D.19345 = ctx->report_error;
  if (D.19345 != 0) goto <D.19346>; else goto <D.19347>;
  <D.19346>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19348 = monoeg_strdup ("Invalid PE header watermark");
    vinfo->info.message = D.19348;
    vinfo->exception_type = 3;
    D.19349 = ctx->errors;
    D.19350 = monoeg_g_slist_prepend (D.19349, vinfo);
    ctx->errors = D.19350;
  }
  <D.19347>:
  ctx->valid = 0;
  return;
  <D.19334>:
  pe_header = pe_header + 4;
  offset = offset + 4;
  D.19351 = ctx->size;
  D.19352 = D.19351 + 4294967276;
  if (D.19352 < offset) goto <D.19353>; else goto <D.19354>;
  <D.19353>:
  D.19345 = ctx->report_error;
  if (D.19345 != 0) goto <D.19355>; else goto <D.19356>;
  <D.19355>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19357 = monoeg_strdup ("File with truncated pe header");
    vinfo->info.message = D.19357;
    vinfo->exception_type = 3;
    D.19349 = ctx->errors;
    D.19358 = monoeg_g_slist_prepend (D.19349, vinfo);
    ctx->errors = D.19358;
  }
  <D.19356>:
  ctx->valid = 0;
  return;
  <D.19354>:
  D.19359 = MEM[(const guint16 *)pe_header];
  if (D.19359 != 332) goto <D.19360>; else goto <D.19361>;
  <D.19360>:
  D.19345 = ctx->report_error;
  if (D.19345 != 0) goto <D.19362>; else goto <D.19363>;
  <D.19362>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19364 = monoeg_strdup ("Invalid PE header Machine value");
    vinfo->info.message = D.19364;
    vinfo->exception_type = 3;
    D.19349 = ctx->errors;
    D.19365 = monoeg_g_slist_prepend (D.19349, vinfo);
    ctx->errors = D.19365;
  }
  <D.19363>:
  ctx->valid = 0;
  return;
  <D.19361>:
}


verify_pe_optional_header (struct VerifyContext * ctx)
{
  const char * D.19367;
  const guint16 * D.19368;
  short unsigned int D.19369;
  int D.19372;
  gchar * D.19375;
  struct GSList * D.19376;
  struct GSList * D.19377;
  unsigned int D.19380;
  unsigned int D.19381;
  gchar * D.19385;
  struct GSList * D.19386;
  short unsigned int D.19387;
  gchar * D.19394;
  struct GSList * D.19395;
  const guint32 * D.19396;
  unsigned int D.19397;
  gchar * D.19402;
  struct GSList * D.19403;
  _Bool D.19404;
  _Bool D.19405;
  _Bool D.19406;
  gchar * D.19411;
  struct GSList * D.19412;
  const guint32 * D.19413;
  unsigned int D.19414;
  gchar * D.19419;
  struct GSList * D.19420;
  gchar * D.19426;
  struct GSList * D.19427;
  int D.19430;
  gchar * D.19431;
  struct GSList * D.19432;
  guint32 offset;
  guint32 header_size;
  guint32 file_alignment;
  const char * pe_header;
  const char * pe_optional_header;

  offset = pe_header_offset (ctx);
  D.19367 = ctx->data;
  pe_header = D.19367 + offset;
  pe_optional_header = pe_header + 20;
  D.19368 = pe_header + 16;
  D.19369 = *D.19368;
  header_size = (guint32) D.19369;
  offset = offset + 20;
  if (header_size <= 1) goto <D.19370>; else goto <D.19371>;
  <D.19370>:
  D.19372 = ctx->report_error;
  if (D.19372 != 0) goto <D.19373>; else goto <D.19374>;
  <D.19373>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19375 = monoeg_strdup ("Invalid PE optional header size");
    vinfo->info.message = D.19375;
    vinfo->exception_type = 3;
    D.19376 = ctx->errors;
    D.19377 = monoeg_g_slist_prepend (D.19376, vinfo);
    ctx->errors = D.19377;
  }
  <D.19374>:
  ctx->valid = 0;
  return;
  <D.19371>:
  D.19380 = ctx->size;
  D.19381 = D.19380 - header_size;
  if (D.19381 < offset) goto <D.19378>; else goto <D.19382>;
  <D.19382>:
  D.19380 = ctx->size;
  if (D.19380 < header_size) goto <D.19378>; else goto <D.19379>;
  <D.19378>:
  D.19372 = ctx->report_error;
  if (D.19372 != 0) goto <D.19383>; else goto <D.19384>;
  <D.19383>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19385 = monoeg_strdup ("Invalid PE optional header size");
    vinfo->info.message = D.19385;
    vinfo->exception_type = 3;
    D.19376 = ctx->errors;
    D.19386 = monoeg_g_slist_prepend (D.19376, vinfo);
    ctx->errors = D.19386;
  }
  <D.19384>:
  ctx->valid = 0;
  return;
  <D.19379>:
  D.19387 = MEM[(const guint16 *)pe_optional_header];
  if (D.19387 == 267) goto <D.19388>; else goto <D.19389>;
  <D.19388>:
  if (header_size != 224) goto <D.19390>; else goto <D.19391>;
  <D.19390>:
  D.19372 = ctx->report_error;
  if (D.19372 != 0) goto <D.19392>; else goto <D.19393>;
  <D.19392>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19394 = monoeg_g_strdup_printf ("Invalid optional header size %d", header_size);
    vinfo->info.message = D.19394;
    vinfo->exception_type = 3;
    D.19376 = ctx->errors;
    D.19395 = monoeg_g_slist_prepend (D.19376, vinfo);
    ctx->errors = D.19395;
  }
  <D.19393>:
  ctx->valid = 0;
  return;
  <D.19391>:
  D.19396 = pe_optional_header + 32;
  D.19397 = *D.19396;
  if (D.19397 != 8192) goto <D.19398>; else goto <D.19399>;
  <D.19398>:
  D.19372 = ctx->report_error;
  if (D.19372 != 0) goto <D.19400>; else goto <D.19401>;
  <D.19400>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19396 = pe_optional_header + 32;
    D.19397 = *D.19396;
    D.19402 = monoeg_g_strdup_printf ("Invalid Section Aligmnent %x", D.19397);
    vinfo->info.message = D.19402;
    vinfo->exception_type = 3;
    D.19376 = ctx->errors;
    D.19403 = monoeg_g_slist_prepend (D.19376, vinfo);
    ctx->errors = D.19403;
  }
  <D.19401>:
  ctx->valid = 0;
  return;
  <D.19399>:
  file_alignment = MEM[(const guint32 *)pe_optional_header + 36B];
  D.19404 = file_alignment != 512;
  D.19405 = file_alignment != 4096;
  D.19406 = D.19404 & D.19405;
  if (D.19406 != 0) goto <D.19407>; else goto <D.19408>;
  <D.19407>:
  D.19372 = ctx->report_error;
  if (D.19372 != 0) goto <D.19409>; else goto <D.19410>;
  <D.19409>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19411 = monoeg_g_strdup_printf ("Invalid file Aligmnent %x", file_alignment);
    vinfo->info.message = D.19411;
    vinfo->exception_type = 3;
    D.19376 = ctx->errors;
    D.19412 = monoeg_g_slist_prepend (D.19376, vinfo);
    ctx->errors = D.19412;
  }
  <D.19410>:
  ctx->valid = 0;
  return;
  <D.19408>:
  D.19413 = pe_optional_header + 92;
  D.19414 = *D.19413;
  if (D.19414 > 16) goto <D.19415>; else goto <D.19416>;
  <D.19415>:
  D.19372 = ctx->report_error;
  if (D.19372 != 0) goto <D.19417>; else goto <D.19418>;
  <D.19417>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19413 = pe_optional_header + 92;
    D.19414 = *D.19413;
    D.19419 = monoeg_g_strdup_printf ("Too many data directories %x", D.19414);
    vinfo->info.message = D.19419;
    vinfo->exception_type = 3;
    D.19376 = ctx->errors;
    D.19420 = monoeg_g_slist_prepend (D.19376, vinfo);
    ctx->errors = D.19420;
  }
  <D.19418>:
  ctx->valid = 0;
  return;
  <D.19416>:
  goto <D.19421>;
  <D.19389>:
  D.19387 = MEM[(const guint16 *)pe_optional_header];
  if (D.19387 == 523) goto <D.19422>; else goto <D.19423>;
  <D.19422>:
  D.19372 = ctx->report_error;
  if (D.19372 != 0) goto <D.19424>; else goto <D.19425>;
  <D.19424>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19426 = monoeg_strdup ("Metadata verifier doesn\'t handle PE32+");
    vinfo->info.message = D.19426;
    vinfo->exception_type = 3;
    D.19376 = ctx->errors;
    D.19427 = monoeg_g_slist_prepend (D.19376, vinfo);
    ctx->errors = D.19427;
  }
  <D.19425>:
  ctx->valid = 0;
  return;
  <D.19423>:
  D.19372 = ctx->report_error;
  if (D.19372 != 0) goto <D.19428>; else goto <D.19429>;
  <D.19428>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19387 = MEM[(const guint16 *)pe_optional_header];
    D.19430 = (int) D.19387;
    D.19431 = monoeg_g_strdup_printf ("Invalid optional header magic %d", D.19430);
    vinfo->info.message = D.19431;
    vinfo->exception_type = 3;
    D.19376 = ctx->errors;
    D.19432 = monoeg_g_slist_prepend (D.19376, vinfo);
    ctx->errors = D.19432;
  }
  <D.19429>:
  ctx->valid = 0;
  return;
  <D.19421>:
}


pe_header_offset (struct VerifyContext * ctx)
{
  guint32 D.19434;
  const char * D.19435;
  const guint32 * D.19436;
  unsigned int D.19437;

  D.19435 = ctx->data;
  D.19436 = D.19435 + 60;
  D.19437 = *D.19436;
  D.19434 = D.19437 + 4;
  return D.19434;
}


load_section_table (struct VerifyContext * ctx)
{
  const char * D.19439;
  const guint16 * D.19440;
  short unsigned int D.19441;
  unsigned int D.19442;
  unsigned int D.19443;
  int D.19444;
  int D.19445;
  unsigned int D.19446;
  unsigned int D.19447;
  unsigned int D.19448;
  int D.19451;
  gchar * D.19454;
  struct GSList * D.19455;
  struct GSList * D.19456;
  unsigned int D.19457;
  unsigned int D.19458;
  void * D.19459;
  unsigned int i.0;
  unsigned int D.19461;
  struct SectionHeader * D.19462;
  unsigned int D.19463;
  unsigned int D.19464;
  unsigned int D.19465;
  unsigned int D.19466;
  short unsigned int D.19467;
  unsigned int D.19468;
  gchar * D.19473;
  struct GSList * D.19474;
  gchar * D.19479;
  struct GSList * D.19480;
  unsigned int D.19481;
  unsigned int D.19482;
  gchar * D.19487;
  struct GSList * D.19488;
  gchar * D.19493;
  struct GSList * D.19494;
  gchar * D.19499;
  struct GSList * D.19500;
  unsigned int D.19503;
  short unsigned int D.19505;
  gchar * D.19508;
  struct GSList * D.19509;
  unsigned int D.19513;
  gchar * D.19516;
  struct GSList * D.19517;
  int i;
  struct SectionHeader * sections;
  guint32 offset;
  const char * ptr;
  guint16 num_sections;

  offset = pe_header_offset (ctx);
  D.19439 = ctx->data;
  ptr = D.19439 + offset;
  D.19440 = ptr + 2;
  D.19441 = *D.19440;
  D.19442 = (unsigned int) D.19441;
  ctx->section_count = D.19442;
  D.19443 = ctx->section_count;
  num_sections = (guint16) D.19443;
  offset = offset + 244;
  ptr = ptr + 244;
  D.19444 = (int) num_sections;
  D.19445 = D.19444 * 40;
  D.19446 = (unsigned int) D.19445;
  D.19447 = ctx->size;
  D.19448 = D.19447 - offset;
  if (D.19446 > D.19448) goto <D.19449>; else goto <D.19450>;
  <D.19449>:
  D.19451 = ctx->report_error;
  if (D.19451 != 0) goto <D.19452>; else goto <D.19453>;
  <D.19452>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19454 = monoeg_strdup ("Invalid PE optional header size");
    vinfo->info.message = D.19454;
    vinfo->exception_type = 3;
    D.19455 = ctx->errors;
    D.19456 = monoeg_g_slist_prepend (D.19455, vinfo);
    ctx->errors = D.19456;
  }
  <D.19453>:
  ctx->valid = 0;
  return;
  <D.19450>:
  D.19457 = (unsigned int) num_sections;
  D.19458 = D.19457 * 20;
  D.19459 = monoeg_malloc0 (D.19458);
  ctx->sections = D.19459;
  sections = ctx->sections;
  i = 0;
  goto <D.17456>;
  <D.17455>:
  i.0 = (unsigned int) i;
  D.19461 = i.0 * 20;
  D.19462 = sections + D.19461;
  D.19463 = MEM[(const guint32 *)ptr + 8B];
  D.19462->size = D.19463;
  i.0 = (unsigned int) i;
  D.19461 = i.0 * 20;
  D.19462 = sections + D.19461;
  D.19464 = MEM[(const guint32 *)ptr + 12B];
  D.19462->baseRVA = D.19464;
  i.0 = (unsigned int) i;
  D.19461 = i.0 * 20;
  D.19462 = sections + D.19461;
  D.19465 = MEM[(const guint32 *)ptr + 20B];
  D.19462->baseOffset = D.19465;
  i.0 = (unsigned int) i;
  D.19461 = i.0 * 20;
  D.19462 = sections + D.19461;
  D.19466 = MEM[(const guint32 *)ptr + 24B];
  D.19462->rellocationsRVA = D.19466;
  i.0 = (unsigned int) i;
  D.19461 = i.0 * 20;
  D.19462 = sections + D.19461;
  D.19467 = MEM[(const guint16 *)ptr + 32B];
  D.19462->numberOfRelocations = D.19467;
  ptr = ptr + 40;
  i = i + 1;
  <D.17456>:
  D.19444 = (int) num_sections;
  if (D.19444 > i) goto <D.17455>; else goto <D.17457>;
  <D.17457>:
  D.19439 = ctx->data;
  ptr = D.19439 + offset;
  i = 0;
  goto <D.17468>;
  <D.17467>:
  {
    guint32 raw_size;
    guint32 flags;

    i.0 = (unsigned int) i;
    D.19461 = i.0 * 20;
    D.19462 = sections + D.19461;
    D.19468 = D.19462->baseOffset;
    if (D.19468 == 0) goto <D.19469>; else goto <D.19470>;
    <D.19469>:
    D.19451 = ctx->report_error;
    if (D.19451 != 0) goto <D.19471>; else goto <D.19472>;
    <D.19471>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.19473 = monoeg_strdup ("Metadata verifier doesn\'t handle sections with intialized data only");
      vinfo->info.message = D.19473;
      vinfo->exception_type = 3;
      D.19455 = ctx->errors;
      D.19474 = monoeg_g_slist_prepend (D.19455, vinfo);
      ctx->errors = D.19474;
    }
    <D.19472>:
    ctx->valid = 0;
    return;
    <D.19470>:
    i.0 = (unsigned int) i;
    D.19461 = i.0 * 20;
    D.19462 = sections + D.19461;
    D.19468 = D.19462->baseOffset;
    D.19447 = ctx->size;
    if (D.19468 >= D.19447) goto <D.19475>; else goto <D.19476>;
    <D.19475>:
    D.19451 = ctx->report_error;
    if (D.19451 != 0) goto <D.19477>; else goto <D.19478>;
    <D.19477>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      i.0 = (unsigned int) i;
      D.19461 = i.0 * 20;
      D.19462 = sections + D.19461;
      D.19468 = D.19462->baseOffset;
      D.19479 = monoeg_g_strdup_printf ("Invalid PointerToRawData %x points beyond EOF", D.19468);
      vinfo->info.message = D.19479;
      vinfo->exception_type = 3;
      D.19455 = ctx->errors;
      D.19480 = monoeg_g_slist_prepend (D.19455, vinfo);
      ctx->errors = D.19480;
    }
    <D.19478>:
    ctx->valid = 0;
    return;
    <D.19476>:
    i.0 = (unsigned int) i;
    D.19461 = i.0 * 20;
    D.19462 = sections + D.19461;
    D.19481 = D.19462->size;
    D.19447 = ctx->size;
    i.0 = (unsigned int) i;
    D.19461 = i.0 * 20;
    D.19462 = sections + D.19461;
    D.19468 = D.19462->baseOffset;
    D.19482 = D.19447 - D.19468;
    if (D.19481 > D.19482) goto <D.19483>; else goto <D.19484>;
    <D.19483>:
    D.19451 = ctx->report_error;
    if (D.19451 != 0) goto <D.19485>; else goto <D.19486>;
    <D.19485>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.19487 = monoeg_strdup ("Invalid VirtualSize points beyond EOF");
      vinfo->info.message = D.19487;
      vinfo->exception_type = 3;
      D.19455 = ctx->errors;
      D.19488 = monoeg_g_slist_prepend (D.19455, vinfo);
      ctx->errors = D.19488;
    }
    <D.19486>:
    ctx->valid = 0;
    return;
    <D.19484>:
    raw_size = MEM[(const guint32 *)ptr + 16B];
    i.0 = (unsigned int) i;
    D.19461 = i.0 * 20;
    D.19462 = sections + D.19461;
    D.19481 = D.19462->size;
    if (D.19481 > raw_size) goto <D.19489>; else goto <D.19490>;
    <D.19489>:
    D.19451 = ctx->report_error;
    if (D.19451 != 0) goto <D.19491>; else goto <D.19492>;
    <D.19491>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.19493 = monoeg_strdup ("Metadata verifier doesn\'t handle sections with SizeOfRawData < VirtualSize");
      vinfo->info.message = D.19493;
      vinfo->exception_type = 3;
      D.19455 = ctx->errors;
      D.19494 = monoeg_g_slist_prepend (D.19455, vinfo);
      ctx->errors = D.19494;
    }
    <D.19492>:
    ctx->valid = 0;
    return;
    <D.19490>:
    D.19447 = ctx->size;
    i.0 = (unsigned int) i;
    D.19461 = i.0 * 20;
    D.19462 = sections + D.19461;
    D.19468 = D.19462->baseOffset;
    D.19482 = D.19447 - D.19468;
    if (D.19482 < raw_size) goto <D.19495>; else goto <D.19496>;
    <D.19495>:
    D.19451 = ctx->report_error;
    if (D.19451 != 0) goto <D.19497>; else goto <D.19498>;
    <D.19497>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.19499 = monoeg_g_strdup_printf ("Invalid SizeOfRawData %x points beyond EOF", raw_size);
      vinfo->info.message = D.19499;
      vinfo->exception_type = 3;
      D.19455 = ctx->errors;
      D.19500 = monoeg_g_slist_prepend (D.19455, vinfo);
      ctx->errors = D.19500;
    }
    <D.19498>:
    ctx->valid = 0;
    return;
    <D.19496>:
    i.0 = (unsigned int) i;
    D.19461 = i.0 * 20;
    D.19462 = sections + D.19461;
    D.19503 = D.19462->rellocationsRVA;
    if (D.19503 != 0) goto <D.19501>; else goto <D.19504>;
    <D.19504>:
    i.0 = (unsigned int) i;
    D.19461 = i.0 * 20;
    D.19462 = sections + D.19461;
    D.19505 = D.19462->numberOfRelocations;
    if (D.19505 != 0) goto <D.19501>; else goto <D.19502>;
    <D.19501>:
    D.19451 = ctx->report_error;
    if (D.19451 != 0) goto <D.19506>; else goto <D.19507>;
    <D.19506>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.19508 = monoeg_g_strdup_printf ("Metadata verifier doesn\'t handle section relocation");
      vinfo->info.message = D.19508;
      vinfo->exception_type = 3;
      D.19455 = ctx->errors;
      D.19509 = monoeg_g_slist_prepend (D.19455, vinfo);
      ctx->errors = D.19509;
    }
    <D.19507>:
    ctx->valid = 0;
    return;
    <D.19502>:
    flags = MEM[(const guint32 *)ptr + 36B];
    if (flags == 0) goto <D.19510>; else goto <D.19512>;
    <D.19512>:
    D.19513 = flags & 33554207;
    if (D.19513 != 0) goto <D.19510>; else goto <D.19511>;
    <D.19510>:
    D.19451 = ctx->report_error;
    if (D.19451 != 0) goto <D.19514>; else goto <D.19515>;
    <D.19514>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.19516 = monoeg_g_strdup_printf ("Invalid section flags %x", flags);
      vinfo->info.message = D.19516;
      vinfo->exception_type = 3;
      D.19455 = ctx->errors;
      D.19517 = monoeg_g_slist_prepend (D.19455, vinfo);
      ctx->errors = D.19517;
    }
    <D.19515>:
    ctx->valid = 0;
    return;
    <D.19511>:
    ptr = ptr + 40;
  }
  i = i + 1;
  <D.17468>:
  D.19444 = (int) num_sections;
  if (D.19444 > i) goto <D.17467>; else goto <D.17469>;
  <D.17469>:
}


load_data_directories (struct VerifyContext * ctx)
{
  unsigned int D.19519;
  const char * D.19520;
  unsigned int D.19523;
  int D.19526;
  int D.19529;
  gchar * D.19532;
  struct GSList * D.19533;
  struct GSList * D.19534;
  int D.19537;
  gchar * D.19542;
  struct GSList * D.19543;
  unsigned int D.19544;
  guint32 offset;
  const char * ptr;
  int i;

  D.19519 = pe_header_offset (ctx);
  offset = D.19519 + 116;
  D.19520 = ctx->data;
  ptr = D.19520 + offset;
  i = 0;
  goto <D.17485>;
  <D.17484>:
  {
    guint32 rva;
    guint32 size;

    rva = MEM[(const guint32 *)ptr];
    size = MEM[(const guint32 *)ptr + 4B];
    if (i == 4) goto <D.19521>; else goto <D.19522>;
    <D.19521>:
    ptr = ptr + 8;
    // predicted unlikely by continue predictor.
    goto <D.17481>;
    <D.19522>:
    D.19523 = rva | size;
    if (D.19523 != 0) goto <D.19524>; else goto <D.19525>;
    <D.19524>:
    D.19526 = is_valid_data_directory (i);
    if (D.19526 == 0) goto <D.19527>; else goto <D.19528>;
    <D.19527>:
    D.19529 = ctx->report_error;
    if (D.19529 != 0) goto <D.19530>; else goto <D.19531>;
    <D.19530>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.19532 = monoeg_g_strdup_printf ("Invalid data directory %d", i);
      vinfo->info.message = D.19532;
      vinfo->exception_type = 3;
      D.19533 = ctx->errors;
      D.19534 = monoeg_g_slist_prepend (D.19533, vinfo);
      ctx->errors = D.19534;
    }
    <D.19531>:
    ctx->valid = 0;
    return;
    <D.19528>:
    <D.19525>:
    if (rva != 0) goto <D.19535>; else goto <D.19536>;
    <D.19535>:
    D.19537 = bounds_check_virtual_address (ctx, rva, size);
    if (D.19537 == 0) goto <D.19538>; else goto <D.19539>;
    <D.19538>:
    D.19529 = ctx->report_error;
    if (D.19529 != 0) goto <D.19540>; else goto <D.19541>;
    <D.19540>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.19542 = monoeg_g_strdup_printf ("Invalid data directory %d rva/size pair %x/%x", i, rva, size);
      vinfo->info.message = D.19542;
      vinfo->exception_type = 3;
      D.19533 = ctx->errors;
      D.19543 = monoeg_g_slist_prepend (D.19533, vinfo);
      ctx->errors = D.19543;
    }
    <D.19541>:
    ctx->valid = 0;
    return;
    <D.19539>:
    <D.19536>:
    ctx->data_directories[i].rva = rva;
    ctx->data_directories[i].size = size;
    D.19544 = translate_rva (ctx, rva);
    ctx->data_directories[i].translated_offset = D.19544;
    ptr = ptr + 8;
  }
  <D.17481>:
  i = i + 1;
  <D.17485>:
  if (i <= 15) goto <D.17484>; else goto <D.17486>;
  <D.17486>:
}


is_valid_data_directory (int i)
{
  gboolean D.19546;
  int iftmp.1;
  unsigned int i.2;
  unsigned int D.19552;
  _Bool D.19553;
  _Bool D.19554;
  _Bool D.19555;
  _Bool D.19557;
  _Bool D.19558;
  _Bool D.19559;
  _Bool D.19561;
  _Bool D.19562;
  _Bool D.19563;

  i.2 = (unsigned int) i;
  D.19552 = i.2 + 4294967295;
  D.19553 = D.19552 <= 1;
  D.19554 = i == 5;
  D.19555 = D.19553 | D.19554;
  if (D.19555 != 0) goto <D.19548>; else goto <D.19556>;
  <D.19556>:
  D.19557 = i == 12;
  D.19558 = i == 14;
  D.19559 = D.19557 | D.19558;
  if (D.19559 != 0) goto <D.19548>; else goto <D.19560>;
  <D.19560>:
  D.19561 = i == 4;
  D.19562 = i == 6;
  D.19563 = D.19561 | D.19562;
  if (D.19563 != 0) goto <D.19548>; else goto <D.19549>;
  <D.19548>:
  iftmp.1 = 1;
  goto <D.19550>;
  <D.19549>:
  iftmp.1 = 0;
  <D.19550>:
  D.19546 = iftmp.1;
  return D.19546;
}


bounds_check_virtual_address (struct VerifyContext * ctx, guint32 rva, guint32 size)
{
  unsigned int D.19565;
  gboolean D.19568;
  int D.19569;
  struct MonoImage * D.19572;
  unsigned int D.19573;
  struct SectionHeader * D.19578;
  unsigned int i.3;
  unsigned int D.19582;
  struct SectionHeader * D.19583;
  unsigned int D.19584;
  unsigned int D.19585;
  unsigned int i.4;
  unsigned int D.19591;
  int i;

  D.19565 = rva + size;
  if (D.19565 < rva) goto <D.19566>; else goto <D.19567>;
  <D.19566>:
  D.19568 = 0;
  return D.19568;
  <D.19567>:
  D.19569 = ctx->stage;
  if (D.19569 > 0) goto <D.19570>; else goto <D.19571>;
  <D.19570>:
  {
    struct MonoCLIImageInfo * iinfo;
    const int top;
    struct MonoSectionTable * tables;
    int i;

    D.19572 = ctx->image;
    iinfo = D.19572->image_info;
    top = iinfo->cli_section_count;
    tables = iinfo->cli_section_tables;
    i = 0;
    goto <D.17387>;
    <D.17386>:
    {
      guint32 base;
      guint32 end;

      base = tables->st_virtual_address;
      D.19573 = tables->st_raw_data_size;
      end = D.19573 + base;
      if (rva >= base) goto <D.19574>; else goto <D.19575>;
      <D.19574>:
      D.19565 = rva + size;
      if (D.19565 <= end) goto <D.19576>; else goto <D.19577>;
      <D.19576>:
      D.19568 = 1;
      return D.19568;
      <D.19577>:
      <D.19575>:
      tables = tables + 40;
    }
    i = i + 1;
    <D.17387>:
    if (i < top) goto <D.17386>; else goto <D.17388>;
    <D.17388>:
    D.19568 = 0;
    return D.19568;
  }
  <D.19571>:
  D.19578 = ctx->sections;
  if (D.19578 == 0B) goto <D.19579>; else goto <D.19580>;
  <D.19579>:
  D.19568 = 0;
  return D.19568;
  <D.19580>:
  i = 0;
  goto <D.17392>;
  <D.17391>:
  {
    guint32 base;
    guint32 end;

    D.19578 = ctx->sections;
    i.3 = (unsigned int) i;
    D.19582 = i.3 * 20;
    D.19583 = D.19578 + D.19582;
    base = D.19583->baseRVA;
    D.19578 = ctx->sections;
    i.3 = (unsigned int) i;
    D.19582 = i.3 * 20;
    D.19583 = D.19578 + D.19582;
    D.19584 = D.19583->baseRVA;
    D.19578 = ctx->sections;
    i.3 = (unsigned int) i;
    D.19582 = i.3 * 20;
    D.19583 = D.19578 + D.19582;
    D.19585 = D.19583->size;
    end = D.19584 + D.19585;
    if (rva >= base) goto <D.19586>; else goto <D.19587>;
    <D.19586>:
    D.19565 = rva + size;
    if (D.19565 <= end) goto <D.19588>; else goto <D.19589>;
    <D.19588>:
    D.19568 = 1;
    return D.19568;
    <D.19589>:
    <D.19587>:
  }
  i = i + 1;
  <D.17392>:
  i.4 = (unsigned int) i;
  D.19591 = ctx->section_count;
  if (i.4 < D.19591) goto <D.17391>; else goto <D.17393>;
  <D.17393>:
  D.19568 = 0;
  return D.19568;
}


translate_rva (struct VerifyContext * ctx, guint32 rva)
{
  int D.19593;
  guint32 D.19596;
  struct MonoImage * D.19597;
  struct SectionHeader * D.19598;
  unsigned int i.5;
  unsigned int D.19602;
  struct SectionHeader * D.19603;
  unsigned int D.19604;
  unsigned int D.19605;
  _Bool D.19606;
  _Bool D.19607;
  _Bool D.19608;
  unsigned int D.19611;
  unsigned int D.19612;
  guint32 iftmp.6;
  unsigned int D.19614;
  unsigned int i.7;
  unsigned int D.19619;
  int i;

  D.19593 = ctx->stage;
  if (D.19593 > 0) goto <D.19594>; else goto <D.19595>;
  <D.19594>:
  D.19597 = ctx->image;
  D.19596 = mono_cli_rva_image_map (D.19597, rva);
  return D.19596;
  <D.19595>:
  D.19598 = ctx->sections;
  if (D.19598 == 0B) goto <D.19599>; else goto <D.19600>;
  <D.19599>:
  D.19596 = 0;
  return D.19596;
  <D.19600>:
  i = 0;
  goto <D.17413>;
  <D.17412>:
  {
    guint32 base;
    guint32 end;

    D.19598 = ctx->sections;
    i.5 = (unsigned int) i;
    D.19602 = i.5 * 20;
    D.19603 = D.19598 + D.19602;
    base = D.19603->baseRVA;
    D.19598 = ctx->sections;
    i.5 = (unsigned int) i;
    D.19602 = i.5 * 20;
    D.19603 = D.19598 + D.19602;
    D.19604 = D.19603->baseRVA;
    D.19598 = ctx->sections;
    i.5 = (unsigned int) i;
    D.19602 = i.5 * 20;
    D.19603 = D.19598 + D.19602;
    D.19605 = D.19603->size;
    end = D.19604 + D.19605;
    D.19606 = rva >= base;
    D.19607 = rva <= end;
    D.19608 = D.19606 & D.19607;
    if (D.19608 != 0) goto <D.19609>; else goto <D.19610>;
    <D.19609>:
    {
      guint32 res;

      D.19611 = rva - base;
      D.19598 = ctx->sections;
      i.5 = (unsigned int) i;
      D.19602 = i.5 * 20;
      D.19603 = D.19598 + D.19602;
      D.19612 = D.19603->baseOffset;
      res = D.19611 + D.19612;
      D.19614 = ctx->size;
      if (D.19614 > res) goto <D.19615>; else goto <D.19616>;
      <D.19615>:
      iftmp.6 = res;
      goto <D.19617>;
      <D.19616>:
      iftmp.6 = 4294967295;
      <D.19617>:
      D.19596 = iftmp.6;
      return D.19596;
    }
    <D.19610>:
  }
  i = i + 1;
  <D.17413>:
  i.7 = (unsigned int) i;
  D.19619 = ctx->section_count;
  if (i.7 < D.19619) goto <D.17412>; else goto <D.17414>;
  <D.17414>:
  D.19596 = 4294967295;
  return D.19596;
}


verify_import_table (struct VerifyContext * ctx)
{
  const char * D.19621;
  _Bool D.19622;
  long int D.19623;
  long int D.19624;
  unsigned int D.19627;
  int D.19630;
  gchar * D.19633;
  struct GSList * D.19634;
  struct GSList * D.19635;
  int D.19638;
  gchar * D.19643;
  struct GSList * D.19644;
  int D.19647;
  gchar * D.19652;
  struct GSList * D.19653;
  int D.19656;
  gchar * D.19661;
  struct GSList * D.19662;
  unsigned int D.19663;
  const guint32 * D.19668;
  unsigned int D.19669;
  gchar * D.19670;
  struct GSList * D.19671;
  _Bool D.19674;
  long int D.19675;
  long int D.19676;
  int D.19679;
  gchar * D.19684;
  struct GSList * D.19685;
  int D.19688;
  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.19621 = ctx->data;
      ptr = D.19621 + offset;
      D.19622 = offset == 4294967295;
      D.19623 = (long int) D.19622;
      D.19624 = __builtin_expect (D.19623, 0);
      if (D.19624 != 0) goto <D.19625>; else goto <D.19626>;
      <D.19625>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 612, "offset != INVALID_OFFSET");
      <D.19626>:
      D.19627 = it.size;
      if (D.19627 <= 39) goto <D.19628>; else goto <D.19629>;
      <D.19628>:
      D.19630 = ctx->report_error;
      if (D.19630 != 0) goto <D.19631>; else goto <D.19632>;
      <D.19631>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19627 = it.size;
        D.19633 = monoeg_g_strdup_printf ("Import table size %d is smaller than 40", D.19627);
        vinfo->info.message = D.19633;
        vinfo->exception_type = 3;
        D.19634 = ctx->errors;
        D.19635 = monoeg_g_slist_prepend (D.19634, vinfo);
        ctx->errors = D.19635;
      }
      <D.19632>:
      ctx->valid = 0;
      return;
      <D.19629>:
      ilt_rva = MEM[(const guint32 *)ptr];
      if (ilt_rva != 0) goto <D.19636>; else goto <D.19637>;
      <D.19636>:
      D.19638 = bounds_check_virtual_address (ctx, ilt_rva, 8);
      if (D.19638 == 0) goto <D.19639>; else goto <D.19640>;
      <D.19639>:
      D.19630 = ctx->report_error;
      if (D.19630 != 0) goto <D.19641>; else goto <D.19642>;
      <D.19641>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19643 = monoeg_g_strdup_printf ("Invalid Import Lookup Table rva %x", ilt_rva);
        vinfo->info.message = D.19643;
        vinfo->exception_type = 3;
        D.19634 = ctx->errors;
        D.19644 = monoeg_g_slist_prepend (D.19634, vinfo);
        ctx->errors = D.19644;
      }
      <D.19642>:
      ctx->valid = 0;
      return;
      <D.19640>:
      <D.19637>:
      name_rva = MEM[(const guint32 *)ptr + 12B];
      if (name_rva != 0) goto <D.19645>; else goto <D.19646>;
      <D.19645>:
      D.19647 = bounds_check_virtual_address (ctx, name_rva, 12);
      if (D.19647 == 0) goto <D.19648>; else goto <D.19649>;
      <D.19648>:
      D.19630 = ctx->report_error;
      if (D.19630 != 0) goto <D.19650>; else goto <D.19651>;
      <D.19650>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19652 = monoeg_g_strdup_printf ("Invalid Import Table Name rva %x", name_rva);
        vinfo->info.message = D.19652;
        vinfo->exception_type = 3;
        D.19634 = ctx->errors;
        D.19653 = monoeg_g_slist_prepend (D.19634, vinfo);
        ctx->errors = D.19653;
      }
      <D.19651>:
      ctx->valid = 0;
      return;
      <D.19649>:
      <D.19646>:
      iat_rva = MEM[(const guint32 *)ptr + 16B];
      if (iat_rva != 0) goto <D.19654>; else goto <D.19655>;
      <D.19654>:
      D.19656 = bounds_check_virtual_address (ctx, iat_rva, 8);
      if (D.19656 == 0) goto <D.19657>; else goto <D.19658>;
      <D.19657>:
      D.19630 = ctx->report_error;
      if (D.19630 != 0) goto <D.19659>; else goto <D.19660>;
      <D.19659>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19661 = monoeg_g_strdup_printf ("Invalid Import Address Table rva %x", iat_rva);
        vinfo->info.message = D.19661;
        vinfo->exception_type = 3;
        D.19634 = ctx->errors;
        D.19662 = monoeg_g_slist_prepend (D.19634, vinfo);
        ctx->errors = D.19662;
      }
      <D.19660>:
      ctx->valid = 0;
      return;
      <D.19658>:
      D.19663 = ctx->data_directories[12].rva;
      if (D.19663 != iat_rva) goto <D.19664>; else goto <D.19665>;
      <D.19664>:
      D.19630 = ctx->report_error;
      if (D.19630 != 0) goto <D.19666>; else goto <D.19667>;
      <D.19666>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19663 = ctx->data_directories[12].rva;
        D.19668 = ptr + 16;
        D.19669 = *D.19668;
        D.19670 = monoeg_g_strdup_printf ("Import Address Table rva %x different from data directory entry %x", D.19669, D.19663);
        vinfo->info.message = D.19670;
        vinfo->exception_type = 3;
        D.19634 = ctx->errors;
        D.19671 = monoeg_g_slist_prepend (D.19634, vinfo);
        ctx->errors = D.19671;
      }
      <D.19667>:
      ctx->valid = 0;
      return;
      <D.19665>:
      <D.19655>:
      if (name_rva != 0) goto <D.19672>; else goto <D.19673>;
      <D.19672>:
      name_rva = translate_rva (ctx, name_rva);
      D.19674 = name_rva == 4294967295;
      D.19675 = (long int) D.19674;
      D.19676 = __builtin_expect (D.19675, 0);
      if (D.19676 != 0) goto <D.19677>; else goto <D.19678>;
      <D.19677>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 636, "name_rva != INVALID_OFFSET");
      <D.19678>:
      D.19621 = ctx->data;
      ptr = D.19621 + name_rva;
      D.19679 = memcmp ("mscoree.dll", ptr, 12);
      if (D.19679 != 0) goto <D.19680>; else goto <D.19681>;
      <D.19680>:
      {
        char name[12];

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

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.19684 = monoeg_g_strdup_printf ("Invalid Import Table Name: \'%s\'", &name);
              vinfo->info.message = D.19684;
              vinfo->exception_type = 3;
              D.19634 = ctx->errors;
              D.19685 = monoeg_g_slist_prepend (D.19634, vinfo);
              ctx->errors = D.19685;
            }
            <D.19683>:
            ctx->valid = 0;
            return;
          }
        finally
          {
            name = {CLOBBER};
          }
      }
      <D.19681>:
      <D.19673>:
      if (ilt_rva != 0) goto <D.19686>; else goto <D.19687>;
      <D.19686>:
      verify_hint_name_table (ctx, ilt_rva, "Import Lookup Table");
      D.19688 = ctx->valid;
      if (D.19688 == 0) goto <D.19689>; else goto <D.19690>;
      <D.19689>:
      return;
      <D.19690>:
      <D.19687>:
      if (iat_rva != 0) goto <D.19691>; else goto <D.19692>;
      <D.19691>:
      verify_hint_name_table (ctx, iat_rva, "Import Address Table");
      <D.19692>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


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

  D.19698 = __builtin_object_size (__dest, 0);
  D.19697 = __builtin___memcpy_chk (__dest, __src, __len, D.19698);
  return D.19697;
}


verify_hint_name_table (struct VerifyContext * ctx, guint32 import_rva, const char * table_name)
{
  _Bool D.19700;
  long int D.19701;
  long int D.19702;
  const char * D.19705;
  const guint32 * D.19706;
  int D.19707;
  int D.19710;
  gchar * D.19713;
  struct GSList * D.19714;
  struct GSList * D.19715;
  _Bool D.19716;
  long int D.19717;
  long int D.19718;
  sizetype D.19721;
  int D.19722;
  int D.19725;
  gchar * D.19730;
  struct GSList * D.19731;
  const char * ptr;
  guint32 hint_table_rva;

  import_rva = translate_rva (ctx, import_rva);
  D.19700 = import_rva == 4294967295;
  D.19701 = (long int) D.19700;
  D.19702 = __builtin_expect (D.19701, 0);
  if (D.19702 != 0) goto <D.19703>; else goto <D.19704>;
  <D.19703>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 586, "import_rva != INVALID_OFFSET");
  <D.19704>:
  D.19705 = ctx->data;
  D.19706 = D.19705 + import_rva;
  hint_table_rva = *D.19706;
  D.19707 = bounds_check_virtual_address (ctx, hint_table_rva, 14);
  if (D.19707 == 0) goto <D.19708>; else goto <D.19709>;
  <D.19708>:
  D.19710 = ctx->report_error;
  if (D.19710 != 0) goto <D.19711>; else goto <D.19712>;
  <D.19711>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19713 = monoeg_g_strdup_printf ("Invalid Hint/Name rva %d for %s", hint_table_rva, table_name);
    vinfo->info.message = D.19713;
    vinfo->exception_type = 3;
    D.19714 = ctx->errors;
    D.19715 = monoeg_g_slist_prepend (D.19714, vinfo);
    ctx->errors = D.19715;
  }
  <D.19712>:
  ctx->valid = 0;
  return;
  <D.19709>:
  hint_table_rva = translate_rva (ctx, hint_table_rva);
  D.19716 = hint_table_rva == 4294967295;
  D.19717 = (long int) D.19716;
  D.19718 = __builtin_expect (D.19717, 0);
  if (D.19718 != 0) goto <D.19719>; else goto <D.19720>;
  <D.19719>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 593, "hint_table_rva != INVALID_OFFSET");
  <D.19720>:
  D.19705 = ctx->data;
  D.19721 = hint_table_rva + 2;
  ptr = D.19705 + D.19721;
  D.19722 = memcmp ("_CorExeMain", ptr, 12);
  if (D.19722 != 0) goto <D.19723>; else goto <D.19724>;
  <D.19723>:
  D.19725 = memcmp ("_CorDllMain", ptr, 12);
  if (D.19725 != 0) goto <D.19726>; else goto <D.19727>;
  <D.19726>:
  {
    char name[12];

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

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.19730 = monoeg_g_strdup_printf ("Invalid Hint / Name: \'%s\'", &name);
          vinfo->info.message = D.19730;
          vinfo->exception_type = 3;
          D.19714 = ctx->errors;
          D.19731 = monoeg_g_slist_prepend (D.19714, vinfo);
          ctx->errors = D.19731;
        }
        <D.19729>:
        ctx->valid = 0;
        return;
      }
    finally
      {
        name = {CLOBBER};
      }
  }
  <D.19727>:
  <D.19724>:
}


verify_resources_table (struct VerifyContext * ctx)
{
  unsigned int D.19734;
  unsigned int D.19737;
  int D.19740;
  gchar * D.19743;
  struct GSList * D.19744;
  struct GSList * D.19745;
  const char * D.19746;
  _Bool D.19747;
  long int D.19748;
  long int D.19749;
  int D.19752;
  int D.19753;
  int D.19754;
  int D.19755;
  int D.19756;
  unsigned int D.19757;
  gchar * D.19762;
  struct GSList * D.19763;
  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.19734 = it.rva;
      if (D.19734 == 0) goto <D.19735>; else goto <D.19736>;
      <D.19735>:
      return;
      <D.19736>:
      D.19737 = it.size;
      if (D.19737 <= 15) goto <D.19738>; else goto <D.19739>;
      <D.19738>:
      D.19740 = ctx->report_error;
      if (D.19740 != 0) goto <D.19741>; else goto <D.19742>;
      <D.19741>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19737 = it.size;
        D.19743 = monoeg_g_strdup_printf ("Resource section is too small, must be at least 16 bytes long but it\'s %d long", D.19737);
        vinfo->info.message = D.19743;
        vinfo->exception_type = 3;
        D.19744 = ctx->errors;
        D.19745 = monoeg_g_slist_prepend (D.19744, vinfo);
        ctx->errors = D.19745;
      }
      <D.19742>:
      ctx->valid = 0;
      return;
      <D.19739>:
      offset = it.translated_offset;
      D.19746 = ctx->data;
      ptr = D.19746 + offset;
      root = ptr;
      D.19737 = it.size;
      end = root + D.19737;
      D.19747 = offset == 4294967295;
      D.19748 = (long int) D.19747;
      D.19749 = __builtin_expect (D.19748, 0);
      if (D.19749 != 0) goto <D.19750>; else goto <D.19751>;
      <D.19750>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 674, "offset != INVALID_OFFSET");
      <D.19751>:
      named_entries = MEM[(const guint16 *)ptr + 12B];
      id_entries = MEM[(const guint16 *)ptr + 14B];
      D.19752 = (int) named_entries;
      D.19753 = (int) id_entries;
      D.19754 = D.19752 + D.19753;
      D.19755 = D.19754 + 2;
      D.19756 = D.19755 * 8;
      D.19757 = (unsigned int) D.19756;
      D.19737 = it.size;
      if (D.19757 > D.19737) goto <D.19758>; else goto <D.19759>;
      <D.19758>:
      D.19740 = ctx->report_error;
      if (D.19740 != 0) goto <D.19760>; else goto <D.19761>;
      <D.19760>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19737 = it.size;
        D.19752 = (int) named_entries;
        D.19753 = (int) id_entries;
        D.19754 = D.19752 + D.19753;
        D.19762 = monoeg_g_strdup_printf ("Resource section is too small, the number of entries (%d) doesn\'t fit on it\'s size %d", D.19754, D.19737);
        vinfo->info.message = D.19762;
        vinfo->exception_type = 3;
        D.19744 = ctx->errors;
        D.19763 = monoeg_g_slist_prepend (D.19744, vinfo);
        ctx->errors = D.19763;
      }
      <D.19761>:
      ctx->valid = 0;
      return;
      <D.19759>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


cleanup_context (struct VerifyContext * ctx, struct GSList * * error_list)
{
  struct SectionHeader * D.19767;
  struct GSList * D.19770;
  gboolean D.19772;

  D.19767 = ctx->sections;
  monoeg_g_free (D.19767);
  if (error_list != 0B) goto <D.19768>; else goto <D.19769>;
  <D.19768>:
  D.19770 = ctx->errors;
  *error_list = D.19770;
  goto <D.19771>;
  <D.19769>:
  D.19770 = ctx->errors;
  mono_free_verify_list (D.19770);
  <D.19771>:
  D.19772 = ctx->valid;
  return D.19772;
}


mono_verifier_verify_cli_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.19774;
  gboolean D.19777;
  _Bool D.19778;
  int D.19779;
  int D.19780;
  struct VerifyContext ctx;
  void cleanup = <<< error >>>;

  try
    {
      D.19774 = mono_verifier_is_enabled_for_image (image);
      if (D.19774 == 0) goto <D.19775>; else goto <D.19776>;
      <D.19775>:
      D.19777 = 1;
      return D.19777;
      <D.19776>:
      D.19778 = error_list != 0B;
      D.19779 = (int) D.19778;
      init_verify_context (&ctx, image, D.19779);
      ctx.stage = 1;
      verify_cli_header (&ctx);
      D.19780 = ctx.valid;
      if (D.19780 == 0) goto cleanup; else goto <D.19781>;
      <D.19781>:
      verify_metadata_header (&ctx);
      D.19780 = ctx.valid;
      if (D.19780 == 0) goto cleanup; else goto <D.19782>;
      <D.19782>:
      verify_tables_schema (&ctx);
      cleanup:
      D.19777 = cleanup_context (&ctx, error_list);
      return D.19777;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


verify_cli_header (struct VerifyContext * ctx)
{
  unsigned int D.19785;
  int D.19788;
  gchar * D.19791;
  struct GSList * D.19792;
  struct GSList * D.19793;
  unsigned int D.19794;
  gchar * D.19799;
  struct GSList * D.19800;
  const char * D.19801;
  _Bool D.19802;
  long int D.19803;
  long int D.19804;
  short unsigned int D.19807;
  int D.19812;
  gchar * D.19813;
  struct GSList * D.19814;
  const guint32 * D.19815;
  unsigned int D.19816;
  const guint32 * D.19817;
  unsigned int D.19818;
  int D.19819;
  gchar * D.19824;
  struct GSList * D.19825;
  gchar * D.19831;
  struct GSList * D.19832;
  const guint32 * D.19833;
  unsigned int D.19834;
  unsigned int D.19835;
  gchar * D.19840;
  struct GSList * D.19841;
  int D.19844;
  gchar * D.19849;
  struct GSList * D.19850;
  _Bool D.19851;
  _Bool D.19852;
  _Bool D.19853;
  gchar * D.19858;
  struct GSList * D.19859;
  struct DataDirectory it;
  guint32 offset;
  const char * ptr;
  int i;

  try
    {
      it = get_data_dir (ctx, 14); [return slot optimization]
      D.19785 = it.rva;
      if (D.19785 == 0) goto <D.19786>; else goto <D.19787>;
      <D.19786>:
      D.19788 = ctx->report_error;
      if (D.19788 != 0) goto <D.19789>; else goto <D.19790>;
      <D.19789>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19791 = monoeg_g_strdup_printf ("CLI header missing");
        vinfo->info.message = D.19791;
        vinfo->exception_type = 3;
        D.19792 = ctx->errors;
        D.19793 = monoeg_g_slist_prepend (D.19792, vinfo);
        ctx->errors = D.19793;
      }
      <D.19790>:
      ctx->valid = 0;
      return;
      <D.19787>:
      D.19794 = it.size;
      if (D.19794 != 72) goto <D.19795>; else goto <D.19796>;
      <D.19795>:
      D.19788 = ctx->report_error;
      if (D.19788 != 0) goto <D.19797>; else goto <D.19798>;
      <D.19797>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19794 = it.size;
        D.19799 = monoeg_g_strdup_printf ("Invalid cli header size in data directory %d must be 72", D.19794);
        vinfo->info.message = D.19799;
        vinfo->exception_type = 3;
        D.19792 = ctx->errors;
        D.19800 = monoeg_g_slist_prepend (D.19792, vinfo);
        ctx->errors = D.19800;
      }
      <D.19798>:
      ctx->valid = 0;
      return;
      <D.19796>:
      offset = it.translated_offset;
      D.19801 = ctx->data;
      ptr = D.19801 + offset;
      D.19802 = offset == 4294967295;
      D.19803 = (long int) D.19802;
      D.19804 = __builtin_expect (D.19803, 0);
      if (D.19804 != 0) goto <D.19805>; else goto <D.19806>;
      <D.19805>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 721, "offset != INVALID_OFFSET");
      <D.19806>:
      D.19807 = MEM[(const guint16 *)ptr];
      if (D.19807 != 72) goto <D.19808>; else goto <D.19809>;
      <D.19808>:
      D.19788 = ctx->report_error;
      if (D.19788 != 0) goto <D.19810>; else goto <D.19811>;
      <D.19810>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19807 = MEM[(const guint16 *)ptr];
        D.19812 = (int) D.19807;
        D.19813 = monoeg_g_strdup_printf ("Invalid cli header size %d must be 72", D.19812);
        vinfo->info.message = D.19813;
        vinfo->exception_type = 3;
        D.19792 = ctx->errors;
        D.19814 = monoeg_g_slist_prepend (D.19792, vinfo);
        ctx->errors = D.19814;
      }
      <D.19811>:
      ctx->valid = 0;
      return;
      <D.19809>:
      D.19815 = ptr + 12;
      D.19816 = *D.19815;
      D.19817 = ptr + 8;
      D.19818 = *D.19817;
      D.19819 = bounds_check_virtual_address (ctx, D.19818, D.19816);
      if (D.19819 == 0) goto <D.19820>; else goto <D.19821>;
      <D.19820>:
      D.19788 = ctx->report_error;
      if (D.19788 != 0) goto <D.19822>; else goto <D.19823>;
      <D.19822>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19815 = ptr + 12;
        D.19816 = *D.19815;
        D.19817 = ptr + 8;
        D.19818 = *D.19817;
        D.19824 = monoeg_g_strdup_printf ("Invalid medatata section rva/size pair %x/%x", D.19818, D.19816);
        vinfo->info.message = D.19824;
        vinfo->exception_type = 3;
        D.19792 = ctx->errors;
        D.19825 = monoeg_g_slist_prepend (D.19792, vinfo);
        ctx->errors = D.19825;
      }
      <D.19823>:
      ctx->valid = 0;
      return;
      <D.19821>:
      D.19817 = ptr + 8;
      D.19818 = *D.19817;
      if (D.19818 == 0) goto <D.19826>; else goto <D.19828>;
      <D.19828>:
      D.19815 = ptr + 12;
      D.19816 = *D.19815;
      if (D.19816 == 0) goto <D.19826>; else goto <D.19827>;
      <D.19826>:
      D.19788 = ctx->report_error;
      if (D.19788 != 0) goto <D.19829>; else goto <D.19830>;
      <D.19829>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19831 = monoeg_g_strdup_printf ("Missing medatata section in the CLI header");
        vinfo->info.message = D.19831;
        vinfo->exception_type = 3;
        D.19792 = ctx->errors;
        D.19832 = monoeg_g_slist_prepend (D.19792, vinfo);
        ctx->errors = D.19832;
      }
      <D.19830>:
      ctx->valid = 0;
      return;
      <D.19827>:
      D.19833 = ptr + 16;
      D.19834 = *D.19833;
      D.19835 = D.19834 & 4294901748;
      if (D.19835 != 0) goto <D.19836>; else goto <D.19837>;
      <D.19836>:
      D.19788 = ctx->report_error;
      if (D.19788 != 0) goto <D.19838>; else goto <D.19839>;
      <D.19838>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19840 = monoeg_g_strdup_printf ("Invalid CLI header flags");
        vinfo->info.message = D.19840;
        vinfo->exception_type = 3;
        D.19792 = ctx->errors;
        D.19841 = monoeg_g_slist_prepend (D.19792, vinfo);
        ctx->errors = D.19841;
      }
      <D.19839>:
      ctx->valid = 0;
      return;
      <D.19837>:
      ptr = ptr + 24;
      i = 0;
      goto <D.17550>;
      <D.17549>:
      {
        guint32 rva;
        guint32 size;

        rva = MEM[(const guint32 *)ptr];
        size = MEM[(const guint32 *)ptr + 4B];
        if (rva != 0) goto <D.19842>; else goto <D.19843>;
        <D.19842>:
        D.19844 = bounds_check_virtual_address (ctx, rva, size);
        if (D.19844 == 0) goto <D.19845>; else goto <D.19846>;
        <D.19845>:
        D.19788 = ctx->report_error;
        if (D.19788 != 0) goto <D.19847>; else goto <D.19848>;
        <D.19847>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.19849 = monoeg_g_strdup_printf ("Invalid cli section %i rva/size pair %x/%x", i, rva, size);
          vinfo->info.message = D.19849;
          vinfo->exception_type = 3;
          D.19792 = ctx->errors;
          D.19850 = monoeg_g_slist_prepend (D.19792, vinfo);
          ctx->errors = D.19850;
        }
        <D.19848>:
        ctx->valid = 0;
        return;
        <D.19846>:
        <D.19843>:
        ptr = ptr + 8;
        D.19851 = rva != 0;
        D.19852 = i > 1;
        D.19853 = D.19851 & D.19852;
        if (D.19853 != 0) goto <D.19854>; else goto <D.19855>;
        <D.19854>:
        D.19788 = ctx->report_error;
        if (D.19788 != 0) goto <D.19856>; else goto <D.19857>;
        <D.19856>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.19858 = monoeg_g_strdup_printf ("Metadata verifier doesn\'t support cli header section %d", i);
          vinfo->info.message = D.19858;
          vinfo->exception_type = 3;
          D.19792 = ctx->errors;
          D.19859 = monoeg_g_slist_prepend (D.19792, vinfo);
          ctx->errors = D.19859;
        }
        <D.19857>:
        ctx->valid = 0;
        return;
        <D.19855>:
      }
      i = i + 1;
      <D.17550>:
      if (i <= 5) goto <D.17549>; else goto <D.17551>;
      <D.17551>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


get_data_dir (struct VerifyContext * ctx, int idx)
{
  struct MonoImage * D.19864;
  unsigned int idx.8;
  unsigned int D.19866;
  unsigned int D.19867;
  unsigned int D.19868;
  unsigned int D.19869;
  unsigned int D.19870;
  struct MonoCLIImageInfo * iinfo;
  struct MonoPEDirEntry * entry;
  struct DataDirectory res;

  try
    {
      D.19864 = ctx->image;
      iinfo = D.19864->image_info;
      entry = &iinfo->cli_header.datadir.pe_export_table;
      idx.8 = (unsigned int) idx;
      D.19866 = idx.8 * 8;
      entry = entry + D.19866;
      D.19867 = entry->rva;
      res.rva = D.19867;
      D.19868 = entry->size;
      res.size = D.19868;
      D.19869 = res.rva;
      D.19870 = translate_rva (ctx, D.19869);
      res.translated_offset = D.19870;
      <retval> = res;
      return <retval>;
    }
  finally
    {
      res = {CLOBBER};
    }
}


verify_metadata_header (struct VerifyContext * ctx)
{
  const char * D.19873;
  _Bool D.19874;
  long int D.19875;
  long int D.19876;
  unsigned int D.19879;
  unsigned int D.19880;
  unsigned int D.19883;
  int D.19886;
  gchar * D.19889;
  struct GSList * D.19890;
  struct GSList * D.19891;
  gchar * D.19896;
  struct GSList * D.19897;
  const guint32 * D.19898;
  unsigned int D.19899;
  unsigned int D.19900;
  unsigned int D.19901;
  int D.19902;
  unsigned int D.19907;
  unsigned int D.19908;
  unsigned int D.19909;
  gchar * D.19910;
  struct GSList * D.19911;
  const guint16 * D.19912;
  short unsigned int D.19913;
  gchar * D.19918;
  struct GSList * D.19919;
  int D.19920;
  unsigned int D.19925;
  gchar * D.19926;
  struct GSList * D.19927;
  int D.19928;
  gchar * D.19933;
  struct GSList * D.19934;
  unsigned int offset.9;
  int D.19936;
  gchar * D.19941;
  struct GSList * D.19942;
  sizetype string_size.10;
  const char * D.19944;
  char D.19945;
  gchar * D.19951;
  struct GSList * D.19952;
  int D.17586;
  int iftmp.11;
  int D.17582;
  const char[9] * D.19956;
  unsigned char D.19957;
  int D.19958;
  unsigned char D.19959;
  int D.19960;
  _Bool D.19961;
  _Bool D.19962;
  _Bool D.19963;
  const unsigned char * D.19966;
  unsigned char D.19967;
  int D.19968;
  const unsigned char * D.19969;
  unsigned char D.19970;
  int D.19971;
  _Bool D.19972;
  _Bool D.19973;
  const unsigned char * D.19976;
  unsigned char D.19977;
  int D.19978;
  const unsigned char * D.19979;
  unsigned char D.19980;
  int D.19981;
  _Bool D.19982;
  _Bool D.19983;
  const unsigned char * D.19986;
  unsigned char D.19987;
  int D.19988;
  const unsigned char * D.19989;
  unsigned char D.19990;
  int D.19991;
  int D.17595;
  int iftmp.12;
  int D.17591;
  const char[4] * D.19999;
  unsigned char D.20000;
  int D.20001;
  unsigned char D.20002;
  int D.20003;
  _Bool D.20004;
  _Bool D.20005;
  _Bool D.20006;
  const unsigned char * D.20009;
  unsigned char D.20010;
  int D.20011;
  const unsigned char * D.20012;
  unsigned char D.20013;
  int D.20014;
  _Bool D.20015;
  _Bool D.20016;
  const unsigned char * D.20019;
  unsigned char D.20020;
  int D.20021;
  const unsigned char * D.20022;
  unsigned char D.20023;
  int D.20024;
  _Bool D.20025;
  _Bool D.20026;
  const unsigned char * D.20029;
  unsigned char D.20030;
  int D.20031;
  const unsigned char * D.20032;
  unsigned char D.20033;
  int D.20034;
  int D.17604;
  int iftmp.13;
  int D.17600;
  const char[6] * D.20042;
  unsigned char D.20043;
  int D.20044;
  unsigned char D.20045;
  int D.20046;
  _Bool D.20047;
  _Bool D.20048;
  _Bool D.20049;
  const unsigned char * D.20052;
  unsigned char D.20053;
  int D.20054;
  const unsigned char * D.20055;
  unsigned char D.20056;
  int D.20057;
  _Bool D.20058;
  _Bool D.20059;
  const unsigned char * D.20062;
  unsigned char D.20063;
  int D.20064;
  const unsigned char * D.20065;
  unsigned char D.20066;
  int D.20067;
  _Bool D.20068;
  _Bool D.20069;
  const unsigned char * D.20072;
  unsigned char D.20073;
  int D.20074;
  const unsigned char * D.20075;
  unsigned char D.20076;
  int D.20077;
  int D.17613;
  int iftmp.14;
  int D.17609;
  const char[6] * D.20085;
  unsigned char D.20086;
  int D.20087;
  unsigned char D.20088;
  int D.20089;
  _Bool D.20090;
  _Bool D.20091;
  _Bool D.20092;
  const unsigned char * D.20095;
  unsigned char D.20096;
  int D.20097;
  const unsigned char * D.20098;
  unsigned char D.20099;
  int D.20100;
  _Bool D.20101;
  _Bool D.20102;
  const unsigned char * D.20105;
  unsigned char D.20106;
  int D.20107;
  const unsigned char * D.20108;
  unsigned char D.20109;
  int D.20110;
  _Bool D.20111;
  _Bool D.20112;
  const unsigned char * D.20115;
  unsigned char D.20116;
  int D.20117;
  const unsigned char * D.20118;
  unsigned char D.20119;
  int D.20120;
  int D.17622;
  int iftmp.15;
  int D.17618;
  const char[3] * D.20128;
  unsigned char D.20129;
  int D.20130;
  unsigned char D.20131;
  int D.20132;
  _Bool D.20133;
  _Bool D.20134;
  _Bool D.20135;
  const unsigned char * D.20138;
  unsigned char D.20139;
  int D.20140;
  const unsigned char * D.20141;
  unsigned char D.20142;
  int D.20143;
  _Bool D.20144;
  _Bool D.20145;
  const unsigned char * D.20148;
  unsigned char D.20149;
  int D.20150;
  const unsigned char * D.20151;
  unsigned char D.20152;
  int D.20153;
  _Bool D.20154;
  _Bool D.20155;
  const unsigned char * D.20158;
  unsigned char D.20159;
  int D.20160;
  const unsigned char * D.20161;
  unsigned char D.20162;
  int D.20163;
  int D.20168;
  gchar * D.20171;
  struct GSList * D.20172;
  unsigned int D.20173;
  gchar * D.20178;
  struct GSList * D.20179;
  unsigned int i.16;
  unsigned int D.20181;
  gchar * D.20186;
  struct GSList * D.20187;
  unsigned int D.20188;
  gchar * D.20193;
  struct GSList * D.20194;
  int i;
  struct DataDirectory it;
  guint32 offset;
  guint32 section_count;
  const char * ptr;

  try
    {
      it = get_data_dir (ctx, 14); [return slot optimization]
      offset = it.translated_offset;
      D.19873 = ctx->data;
      ptr = D.19873 + offset;
      D.19874 = offset == 4294967295;
      D.19875 = (long int) D.19874;
      D.19876 = __builtin_expect (D.19875, 0);
      if (D.19876 != 0) goto <D.19877>; else goto <D.19878>;
      <D.19877>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 769, "offset != INVALID_OFFSET");
      <D.19878>:
      ptr = ptr + 8;
      D.19879 = MEM[(const guint32 *)ptr];
      it.rva = D.19879;
      ptr = ptr + 4;
      D.19879 = MEM[(const guint32 *)ptr];
      it.size = D.19879;
      D.19880 = it.rva;
      offset = translate_rva (ctx, D.19880);
      it.translated_offset = offset;
      D.19873 = ctx->data;
      ptr = D.19873 + offset;
      D.19874 = offset == 4294967295;
      D.19875 = (long int) D.19874;
      D.19876 = __builtin_expect (D.19875, 0);
      if (D.19876 != 0) goto <D.19881>; else goto <D.19882>;
      <D.19881>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 779, "offset != INVALID_OFFSET");
      <D.19882>:
      D.19883 = it.size;
      if (D.19883 <= 19) goto <D.19884>; else goto <D.19885>;
      <D.19884>:
      D.19886 = ctx->report_error;
      if (D.19886 != 0) goto <D.19887>; else goto <D.19888>;
      <D.19887>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19883 = it.size;
        D.19889 = monoeg_g_strdup_printf ("Metadata root section is too small %d (at least 20 bytes required for initial decoding)", D.19883);
        vinfo->info.message = D.19889;
        vinfo->exception_type = 3;
        D.19890 = ctx->errors;
        D.19891 = monoeg_g_slist_prepend (D.19890, vinfo);
        ctx->errors = D.19891;
      }
      <D.19888>:
      ctx->valid = 0;
      return;
      <D.19885>:
      D.19879 = MEM[(const guint32 *)ptr];
      if (D.19879 != 1112167234) goto <D.19892>; else goto <D.19893>;
      <D.19892>:
      D.19886 = ctx->report_error;
      if (D.19886 != 0) goto <D.19894>; else goto <D.19895>;
      <D.19894>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19879 = MEM[(const guint32 *)ptr];
        D.19896 = monoeg_g_strdup_printf ("Invalid metadata signature, expected 0x424A5342 but got %08x", D.19879);
        vinfo->info.message = D.19896;
        vinfo->exception_type = 3;
        D.19890 = ctx->errors;
        D.19897 = monoeg_g_slist_prepend (D.19890, vinfo);
        ctx->errors = D.19897;
      }
      <D.19895>:
      ctx->valid = 0;
      return;
      <D.19893>:
      D.19898 = ptr + 12;
      D.19899 = *D.19898;
      D.19900 = D.19899 + offset;
      D.19901 = D.19900 + 16;
      offset = pad4 (D.19901);
      D.19902 = bounds_check_datadir (&it, offset, 4);
      if (D.19902 == 0) goto <D.19903>; else goto <D.19904>;
      <D.19903>:
      D.19886 = ctx->report_error;
      if (D.19886 != 0) goto <D.19905>; else goto <D.19906>;
      <D.19905>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19907 = it.translated_offset;
        D.19908 = offset - D.19907;
        D.19909 = D.19908 + 4;
        D.19883 = it.size;
        D.19910 = monoeg_g_strdup_printf ("Metadata root section is too small %d (at least %d bytes required for flags decoding)", D.19883, D.19909);
        vinfo->info.message = D.19910;
        vinfo->exception_type = 3;
        D.19890 = ctx->errors;
        D.19911 = monoeg_g_slist_prepend (D.19890, vinfo);
        ctx->errors = D.19911;
      }
      <D.19906>:
      ctx->valid = 0;
      return;
      <D.19904>:
      D.19873 = ctx->data;
      ptr = D.19873 + offset;
      D.19912 = ptr + 2;
      D.19913 = *D.19912;
      section_count = (guint32) D.19913;
      if (section_count <= 1) goto <D.19914>; else goto <D.19915>;
      <D.19914>:
      D.19886 = ctx->report_error;
      if (D.19886 != 0) goto <D.19916>; else goto <D.19917>;
      <D.19916>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19918 = monoeg_g_strdup_printf ("Metadata root section must have at least 2 streams (#~ and #GUID)");
        vinfo->info.message = D.19918;
        vinfo->exception_type = 3;
        D.19890 = ctx->errors;
        D.19919 = monoeg_g_slist_prepend (D.19890, vinfo);
        ctx->errors = D.19919;
      }
      <D.19917>:
      ctx->valid = 0;
      return;
      <D.19915>:
      ptr = ptr + 4;
      offset = offset + 4;
      i = 0;
      goto <D.17627>;
      <D.17626>:
      {
        guint32 stream_off;
        guint32 stream_size;
        int string_size;
        int stream_idx;

        D.19920 = bounds_check_datadir (&it, offset, 8);
        if (D.19920 == 0) goto <D.19921>; else goto <D.19922>;
        <D.19921>:
        D.19886 = ctx->report_error;
        if (D.19886 != 0) goto <D.19923>; else goto <D.19924>;
        <D.19923>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.19907 = it.translated_offset;
          D.19908 = offset - D.19907;
          D.19925 = D.19908 + 9;
          D.19926 = monoeg_g_strdup_printf ("Metadata root section is too small for initial decode of stream header %d, missing %d bytes", i, D.19925);
          vinfo->info.message = D.19926;
          vinfo->exception_type = 3;
          D.19890 = ctx->errors;
          D.19927 = monoeg_g_slist_prepend (D.19890, vinfo);
          ctx->errors = D.19927;
        }
        <D.19924>:
        ctx->valid = 0;
        return;
        <D.19922>:
        D.19907 = it.translated_offset;
        D.19879 = MEM[(const guint32 *)ptr];
        stream_off = D.19907 + D.19879;
        stream_size = MEM[(const guint32 *)ptr + 4B];
        D.19928 = bounds_check_datadir (&it, stream_off, stream_size);
        if (D.19928 == 0) goto <D.19929>; else goto <D.19930>;
        <D.19929>:
        D.19886 = ctx->report_error;
        if (D.19886 != 0) goto <D.19931>; else goto <D.19932>;
        <D.19931>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.19933 = monoeg_g_strdup_printf ("Invalid stream header %d offset/size pair %x/%x", 0, stream_off, stream_size);
          vinfo->info.message = D.19933;
          vinfo->exception_type = 3;
          D.19890 = ctx->errors;
          D.19934 = monoeg_g_slist_prepend (D.19890, vinfo);
          ctx->errors = D.19934;
        }
        <D.19932>:
        ctx->valid = 0;
        return;
        <D.19930>:
        ptr = ptr + 8;
        offset = offset + 8;
        string_size = 0;
        goto <D.17576>;
        <D.17575>:
        offset.9 = offset;
        offset = offset.9 + 1;
        D.19936 = bounds_check_datadir (&it, offset.9, 1);
        if (D.19936 == 0) goto <D.19937>; else goto <D.19938>;
        <D.19937>:
        D.19886 = ctx->report_error;
        if (D.19886 != 0) goto <D.19939>; else goto <D.19940>;
        <D.19939>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.19941 = monoeg_g_strdup_printf ("Metadata root section is too small to decode stream header %d name", i);
          vinfo->info.message = D.19941;
          vinfo->exception_type = 3;
          D.19890 = ctx->errors;
          D.19942 = monoeg_g_slist_prepend (D.19890, vinfo);
          ctx->errors = D.19942;
        }
        <D.19940>:
        ctx->valid = 0;
        return;
        <D.19938>:
        string_size.10 = (sizetype) string_size;
        D.19944 = ptr + string_size.10;
        D.19945 = *D.19944;
        if (D.19945 == 0) goto <D.17574>; else goto <D.19946>;
        <D.19946>:
        string_size = string_size + 1;
        <D.17576>:
        if (string_size <= 31) goto <D.17575>; else goto <D.17574>;
        <D.17574>:
        string_size.10 = (sizetype) string_size;
        D.19944 = ptr + string_size.10;
        D.19945 = *D.19944;
        if (D.19945 != 0) goto <D.19947>; else goto <D.19948>;
        <D.19947>:
        D.19886 = ctx->report_error;
        if (D.19886 != 0) goto <D.19949>; else goto <D.19950>;
        <D.19949>:
        {
          struct MonoVerifyInfoExtended * vinfo;

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

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

            __s2 = ptr;
            D.19956 = "#Strings";
            D.19957 = MEM[(const unsigned char *)D.19956];
            D.19958 = (int) D.19957;
            D.19959 = *__s2;
            D.19960 = (int) D.19959;
            __result = D.19958 - D.19960;
            {
              D.19961 = __s1_len != 0;
              D.19962 = __result == 0;
              D.19963 = D.19961 & D.19962;
              if (D.19963 != 0) goto <D.19964>; else goto <D.19965>;
              <D.19964>:
              D.19966 = &MEM[(void *)"#Strings" + 1B];
              D.19967 = *D.19966;
              D.19968 = (int) D.19967;
              D.19969 = __s2 + 1;
              D.19970 = *D.19969;
              D.19971 = (int) D.19970;
              __result = D.19968 - D.19971;
              D.19972 = __s1_len > 1;
              D.19962 = __result == 0;
              D.19973 = D.19972 & D.19962;
              if (D.19973 != 0) goto <D.19974>; else goto <D.19975>;
              <D.19974>:
              D.19976 = &MEM[(void *)"#Strings" + 2B];
              D.19977 = *D.19976;
              D.19978 = (int) D.19977;
              D.19979 = __s2 + 2;
              D.19980 = *D.19979;
              D.19981 = (int) D.19980;
              __result = D.19978 - D.19981;
              D.19982 = __s1_len > 2;
              D.19962 = __result == 0;
              D.19983 = D.19982 & D.19962;
              if (D.19983 != 0) goto <D.19984>; else goto <D.19985>;
              <D.19984>:
              D.19986 = &MEM[(void *)"#Strings" + 3B];
              D.19987 = *D.19986;
              D.19988 = (int) D.19987;
              D.19989 = __s2 + 3;
              D.19990 = *D.19989;
              D.19991 = (int) D.19990;
              __result = D.19988 - D.19991;
              <D.19985>:
              <D.19975>:
              <D.19965>:
            }
            D.17582 = __result;
          }
          iftmp.11 = D.17582;
          goto <D.19992>;
          <D.19955>:
          iftmp.11 = __builtin_strcmp ("#Strings", ptr);
          <D.19992>:
          D.17586 = iftmp.11;
        }
        if (D.17586 == 0) goto <D.19993>; else goto <D.19994>;
        <D.19993>:
        stream_idx = 0;
        goto <D.19995>;
        <D.19994>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = ptr;
            D.19999 = "#US";
            D.20000 = MEM[(const unsigned char *)D.19999];
            D.20001 = (int) D.20000;
            D.20002 = *__s2;
            D.20003 = (int) D.20002;
            __result = D.20001 - D.20003;
            {
              D.20004 = __s1_len != 0;
              D.20005 = __result == 0;
              D.20006 = D.20004 & D.20005;
              if (D.20006 != 0) goto <D.20007>; else goto <D.20008>;
              <D.20007>:
              D.20009 = &MEM[(void *)"#US" + 1B];
              D.20010 = *D.20009;
              D.20011 = (int) D.20010;
              D.20012 = __s2 + 1;
              D.20013 = *D.20012;
              D.20014 = (int) D.20013;
              __result = D.20011 - D.20014;
              D.20015 = __s1_len > 1;
              D.20005 = __result == 0;
              D.20016 = D.20015 & D.20005;
              if (D.20016 != 0) goto <D.20017>; else goto <D.20018>;
              <D.20017>:
              D.20019 = &MEM[(void *)"#US" + 2B];
              D.20020 = *D.20019;
              D.20021 = (int) D.20020;
              D.20022 = __s2 + 2;
              D.20023 = *D.20022;
              D.20024 = (int) D.20023;
              __result = D.20021 - D.20024;
              D.20025 = __s1_len > 2;
              D.20005 = __result == 0;
              D.20026 = D.20025 & D.20005;
              if (D.20026 != 0) goto <D.20027>; else goto <D.20028>;
              <D.20027>:
              D.20029 = &MEM[(void *)"#US" + 3B];
              D.20030 = *D.20029;
              D.20031 = (int) D.20030;
              D.20032 = __s2 + 3;
              D.20033 = *D.20032;
              D.20034 = (int) D.20033;
              __result = D.20031 - D.20034;
              <D.20028>:
              <D.20018>:
              <D.20008>:
            }
            D.17591 = __result;
          }
          iftmp.12 = D.17591;
          goto <D.20035>;
          <D.19998>:
          iftmp.12 = __builtin_strcmp ("#US", ptr);
          <D.20035>:
          D.17595 = iftmp.12;
        }
        if (D.17595 == 0) goto <D.20036>; else goto <D.20037>;
        <D.20036>:
        stream_idx = 1;
        goto <D.20038>;
        <D.20037>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = ptr;
            D.20042 = "#Blob";
            D.20043 = MEM[(const unsigned char *)D.20042];
            D.20044 = (int) D.20043;
            D.20045 = *__s2;
            D.20046 = (int) D.20045;
            __result = D.20044 - D.20046;
            {
              D.20047 = __s1_len != 0;
              D.20048 = __result == 0;
              D.20049 = D.20047 & D.20048;
              if (D.20049 != 0) goto <D.20050>; else goto <D.20051>;
              <D.20050>:
              D.20052 = &MEM[(void *)"#Blob" + 1B];
              D.20053 = *D.20052;
              D.20054 = (int) D.20053;
              D.20055 = __s2 + 1;
              D.20056 = *D.20055;
              D.20057 = (int) D.20056;
              __result = D.20054 - D.20057;
              D.20058 = __s1_len > 1;
              D.20048 = __result == 0;
              D.20059 = D.20058 & D.20048;
              if (D.20059 != 0) goto <D.20060>; else goto <D.20061>;
              <D.20060>:
              D.20062 = &MEM[(void *)"#Blob" + 2B];
              D.20063 = *D.20062;
              D.20064 = (int) D.20063;
              D.20065 = __s2 + 2;
              D.20066 = *D.20065;
              D.20067 = (int) D.20066;
              __result = D.20064 - D.20067;
              D.20068 = __s1_len > 2;
              D.20048 = __result == 0;
              D.20069 = D.20068 & D.20048;
              if (D.20069 != 0) goto <D.20070>; else goto <D.20071>;
              <D.20070>:
              D.20072 = &MEM[(void *)"#Blob" + 3B];
              D.20073 = *D.20072;
              D.20074 = (int) D.20073;
              D.20075 = __s2 + 3;
              D.20076 = *D.20075;
              D.20077 = (int) D.20076;
              __result = D.20074 - D.20077;
              <D.20071>:
              <D.20061>:
              <D.20051>:
            }
            D.17600 = __result;
          }
          iftmp.13 = D.17600;
          goto <D.20078>;
          <D.20041>:
          iftmp.13 = __builtin_strcmp ("#Blob", ptr);
          <D.20078>:
          D.17604 = iftmp.13;
        }
        if (D.17604 == 0) goto <D.20079>; else goto <D.20080>;
        <D.20079>:
        stream_idx = 2;
        goto <D.20081>;
        <D.20080>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = ptr;
            D.20085 = "#GUID";
            D.20086 = MEM[(const unsigned char *)D.20085];
            D.20087 = (int) D.20086;
            D.20088 = *__s2;
            D.20089 = (int) D.20088;
            __result = D.20087 - D.20089;
            {
              D.20090 = __s1_len != 0;
              D.20091 = __result == 0;
              D.20092 = D.20090 & D.20091;
              if (D.20092 != 0) goto <D.20093>; else goto <D.20094>;
              <D.20093>:
              D.20095 = &MEM[(void *)"#GUID" + 1B];
              D.20096 = *D.20095;
              D.20097 = (int) D.20096;
              D.20098 = __s2 + 1;
              D.20099 = *D.20098;
              D.20100 = (int) D.20099;
              __result = D.20097 - D.20100;
              D.20101 = __s1_len > 1;
              D.20091 = __result == 0;
              D.20102 = D.20101 & D.20091;
              if (D.20102 != 0) goto <D.20103>; else goto <D.20104>;
              <D.20103>:
              D.20105 = &MEM[(void *)"#GUID" + 2B];
              D.20106 = *D.20105;
              D.20107 = (int) D.20106;
              D.20108 = __s2 + 2;
              D.20109 = *D.20108;
              D.20110 = (int) D.20109;
              __result = D.20107 - D.20110;
              D.20111 = __s1_len > 2;
              D.20091 = __result == 0;
              D.20112 = D.20111 & D.20091;
              if (D.20112 != 0) goto <D.20113>; else goto <D.20114>;
              <D.20113>:
              D.20115 = &MEM[(void *)"#GUID" + 3B];
              D.20116 = *D.20115;
              D.20117 = (int) D.20116;
              D.20118 = __s2 + 3;
              D.20119 = *D.20118;
              D.20120 = (int) D.20119;
              __result = D.20117 - D.20120;
              <D.20114>:
              <D.20104>:
              <D.20094>:
            }
            D.17609 = __result;
          }
          iftmp.14 = D.17609;
          goto <D.20121>;
          <D.20084>:
          iftmp.14 = __builtin_strcmp ("#GUID", ptr);
          <D.20121>:
          D.17613 = iftmp.14;
        }
        if (D.17613 == 0) goto <D.20122>; else goto <D.20123>;
        <D.20122>:
        stream_idx = 3;
        goto <D.20124>;
        <D.20123>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = ptr;
            D.20128 = "#~";
            D.20129 = MEM[(const unsigned char *)D.20128];
            D.20130 = (int) D.20129;
            D.20131 = *__s2;
            D.20132 = (int) D.20131;
            __result = D.20130 - D.20132;
            {
              D.20133 = __s1_len != 0;
              D.20134 = __result == 0;
              D.20135 = D.20133 & D.20134;
              if (D.20135 != 0) goto <D.20136>; else goto <D.20137>;
              <D.20136>:
              D.20138 = &MEM[(void *)"#~" + 1B];
              D.20139 = *D.20138;
              D.20140 = (int) D.20139;
              D.20141 = __s2 + 1;
              D.20142 = *D.20141;
              D.20143 = (int) D.20142;
              __result = D.20140 - D.20143;
              D.20144 = __s1_len > 1;
              D.20134 = __result == 0;
              D.20145 = D.20144 & D.20134;
              if (D.20145 != 0) goto <D.20146>; else goto <D.20147>;
              <D.20146>:
              D.20148 = &MEM[(void *)"#~" + 2B];
              D.20149 = *D.20148;
              D.20150 = (int) D.20149;
              D.20151 = __s2 + 2;
              D.20152 = *D.20151;
              D.20153 = (int) D.20152;
              __result = D.20150 - D.20153;
              D.20154 = __s1_len > 2;
              D.20134 = __result == 0;
              D.20155 = D.20154 & D.20134;
              if (D.20155 != 0) goto <D.20156>; else goto <D.20157>;
              <D.20156>:
              D.20158 = &MEM[(void *)"#~" + 3B];
              D.20159 = *D.20158;
              D.20160 = (int) D.20159;
              D.20161 = __s2 + 3;
              D.20162 = *D.20161;
              D.20163 = (int) D.20162;
              __result = D.20160 - D.20163;
              <D.20157>:
              <D.20147>:
              <D.20137>:
            }
            D.17618 = __result;
          }
          iftmp.15 = D.17618;
          goto <D.20164>;
          <D.20127>:
          iftmp.15 = __builtin_strcmp ("#~", ptr);
          <D.20164>:
          D.17622 = iftmp.15;
        }
        if (D.17622 == 0) goto <D.20165>; else goto <D.20166>;
        <D.20165>:
        stream_idx = 4;
        goto <D.20167>;
        <D.20166>:
        D.20168 = ctx->report_warning;
        if (D.20168 != 0) goto <D.20169>; else goto <D.20170>;
        <D.20169>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 2;
          D.20171 = monoeg_g_strdup_printf ("Metadata stream header %d invalid name %s", i, ptr);
          vinfo->info.message = D.20171;
          vinfo->exception_type = 3;
          D.19890 = ctx->errors;
          D.20172 = monoeg_g_slist_prepend (D.19890, vinfo);
          ctx->errors = D.20172;
        }
        ctx->valid = 0;
        return;
        <D.20170>:
        offset = pad4 (offset);
        D.19873 = ctx->data;
        ptr = D.19873 + offset;
        // predicted unlikely by continue predictor.
        goto <D.17624>;
        <D.20167>:
        <D.20124>:
        <D.20081>:
        <D.20038>:
        <D.19995>:
        D.20173 = ctx->metadata_streams[stream_idx].offset;
        if (D.20173 != 0) goto <D.20174>; else goto <D.20175>;
        <D.20174>:
        D.19886 = ctx->report_error;
        if (D.19886 != 0) goto <D.20176>; else goto <D.20177>;
        <D.20176>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.20178 = monoeg_g_strdup_printf ("Duplicated metadata stream header %s", ptr);
          vinfo->info.message = D.20178;
          vinfo->exception_type = 3;
          D.19890 = ctx->errors;
          D.20179 = monoeg_g_slist_prepend (D.19890, vinfo);
          ctx->errors = D.20179;
        }
        <D.20177>:
        ctx->valid = 0;
        return;
        <D.20175>:
        ctx->metadata_streams[stream_idx].offset = stream_off;
        ctx->metadata_streams[stream_idx].size = stream_size;
        offset = pad4 (offset);
        D.19873 = ctx->data;
        ptr = D.19873 + offset;
      }
      <D.17624>:
      i = i + 1;
      <D.17627>:
      i.16 = (unsigned int) i;
      if (i.16 < section_count) goto <D.17626>; else goto <D.17628>;
      <D.17628>:
      D.20181 = ctx->metadata_streams[4].size;
      if (D.20181 == 0) goto <D.20182>; else goto <D.20183>;
      <D.20182>:
      D.19886 = ctx->report_error;
      if (D.19886 != 0) goto <D.20184>; else goto <D.20185>;
      <D.20184>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20186 = monoeg_g_strdup_printf ("Metadata #~ stream missing");
        vinfo->info.message = D.20186;
        vinfo->exception_type = 3;
        D.19890 = ctx->errors;
        D.20187 = monoeg_g_slist_prepend (D.19890, vinfo);
        ctx->errors = D.20187;
      }
      <D.20185>:
      ctx->valid = 0;
      return;
      <D.20183>:
      D.20188 = ctx->metadata_streams[3].size;
      if (D.20188 == 0) goto <D.20189>; else goto <D.20190>;
      <D.20189>:
      D.19886 = ctx->report_error;
      if (D.19886 != 0) goto <D.20191>; else goto <D.20192>;
      <D.20191>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20193 = monoeg_g_strdup_printf ("Metadata guid stream missing");
        vinfo->info.message = D.20193;
        vinfo->exception_type = 3;
        D.19890 = ctx->errors;
        D.20194 = monoeg_g_slist_prepend (D.19890, vinfo);
        ctx->errors = D.20194;
      }
      <D.20192>:
      ctx->valid = 0;
      return;
      <D.20190>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


bounds_check_datadir (struct DataDirectory * dir, guint32 offset, guint32 size)
{
  unsigned int D.20198;
  gboolean D.20201;
  unsigned int D.20202;
  unsigned int D.20205;
  unsigned int D.20206;
  _Bool D.20207;

  D.20198 = dir->translated_offset;
  if (D.20198 > offset) goto <D.20199>; else goto <D.20200>;
  <D.20199>:
  D.20201 = 0;
  return D.20201;
  <D.20200>:
  D.20202 = dir->size;
  if (D.20202 < size) goto <D.20203>; else goto <D.20204>;
  <D.20203>:
  D.20201 = 0;
  return D.20201;
  <D.20204>:
  D.20205 = offset + size;
  D.20198 = dir->translated_offset;
  D.20202 = dir->size;
  D.20206 = D.20198 + D.20202;
  D.20207 = D.20205 <= D.20206;
  D.20201 = (gboolean) D.20207;
  return D.20201;
}


pad4 (guint32 offset)
{
  unsigned int D.20209;
  unsigned int D.20212;
  guint32 D.20213;

  D.20209 = offset & 3;
  if (D.20209 != 0) goto <D.20210>; else goto <D.20211>;
  <D.20210>:
  D.20212 = offset & 4294967292;
  offset = D.20212 + 4;
  <D.20211>:
  D.20213 = offset;
  return D.20213;
}


verify_tables_schema (struct VerifyContext * ctx)
{
  const char * D.20215;
  unsigned int D.20216;
  int D.20219;
  gchar * D.20222;
  struct GSList * D.20223;
  struct GSList * D.20224;
  const char * D.20225;
  char D.20226;
  unsigned char D.20227;
  unsigned char D.20228;
  int D.20233;
  gchar * D.20234;
  struct GSList * D.20235;
  const char * D.20236;
  char D.20237;
  int D.20242;
  gchar * D.20243;
  struct GSList * D.20244;
  const char * D.20245;
  char D.20246;
  signed char D.20247;
  unsigned char * D.20252;
  unsigned char D.20253;
  int D.20254;
  gchar * D.20255;
  struct GSList * D.20256;
  long long unsigned int D.20257;
  long long unsigned int D.20258;
  _Bool D.20263;
  _Bool D.20264;
  _Bool D.20265;
  _Bool D.20267;
  _Bool D.20268;
  _Bool D.20269;
  gchar * D.20273;
  struct GSList * D.20274;
  unsigned int i.17;
  unsigned int D.20276;
  _Bool D.20277;
  _Bool D.20278;
  _Bool D.20279;
  gchar * D.20284;
  struct GSList * D.20285;
  unsigned int D.20286;
  unsigned int D.20287;
  gchar * D.20292;
  struct GSList * D.20293;
  gchar * D.20300;
  struct GSList * D.20301;
  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.20215 = ctx->data;
      ptr = D.20215 + offset;
      D.20216 = tables_area.size;
      if (D.20216 <= 23) goto <D.20217>; else goto <D.20218>;
      <D.20217>:
      D.20219 = ctx->report_error;
      if (D.20219 != 0) goto <D.20220>; else goto <D.20221>;
      <D.20220>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20216 = tables_area.size;
        D.20222 = monoeg_g_strdup_printf ("Table schemata size (%d) too small to for initial decoding (requires 24 bytes)", D.20216);
        vinfo->info.message = D.20222;
        vinfo->exception_type = 3;
        D.20223 = ctx->errors;
        D.20224 = monoeg_g_slist_prepend (D.20223, vinfo);
        ctx->errors = D.20224;
      }
      <D.20221>:
      ctx->valid = 0;
      return;
      <D.20218>:
      D.20225 = ptr + 4;
      D.20226 = *D.20225;
      D.20227 = (unsigned char) D.20226;
      D.20228 = D.20227 + 255;
      if (D.20228 > 1) goto <D.20229>; else goto <D.20230>;
      <D.20229>:
      D.20219 = ctx->report_error;
      if (D.20219 != 0) goto <D.20231>; else goto <D.20232>;
      <D.20231>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20225 = ptr + 4;
        D.20226 = *D.20225;
        D.20233 = (int) D.20226;
        D.20234 = monoeg_g_strdup_printf ("Invalid table schemata major version %d, expected 2", D.20233);
        vinfo->info.message = D.20234;
        vinfo->exception_type = 3;
        D.20223 = ctx->errors;
        D.20235 = monoeg_g_slist_prepend (D.20223, vinfo);
        ctx->errors = D.20235;
      }
      <D.20232>:
      ctx->valid = 0;
      return;
      <D.20230>:
      D.20236 = ptr + 5;
      D.20237 = *D.20236;
      if (D.20237 != 0) goto <D.20238>; else goto <D.20239>;
      <D.20238>:
      D.20219 = ctx->report_error;
      if (D.20219 != 0) goto <D.20240>; else goto <D.20241>;
      <D.20240>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20236 = ptr + 5;
        D.20237 = *D.20236;
        D.20242 = (int) D.20237;
        D.20243 = monoeg_g_strdup_printf ("Invalid table schemata minor version %d, expected 0", D.20242);
        vinfo->info.message = D.20243;
        vinfo->exception_type = 3;
        D.20223 = ctx->errors;
        D.20244 = monoeg_g_slist_prepend (D.20223, vinfo);
        ctx->errors = D.20244;
      }
      <D.20241>:
      ctx->valid = 0;
      return;
      <D.20239>:
      D.20245 = ptr + 6;
      D.20246 = *D.20245;
      D.20247 = D.20246 & -8;
      if (D.20247 != 0) goto <D.20248>; else goto <D.20249>;
      <D.20248>:
      D.20219 = ctx->report_error;
      if (D.20219 != 0) goto <D.20250>; else goto <D.20251>;
      <D.20250>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20252 = ptr + 6;
        D.20253 = *D.20252;
        D.20254 = (int) D.20253;
        D.20255 = monoeg_g_strdup_printf ("Invalid table schemata heap sizes 0x%02x, only bits 0, 1 and 2 can be set", D.20254);
        vinfo->info.message = D.20255;
        vinfo->exception_type = 3;
        D.20223 = ctx->errors;
        D.20256 = monoeg_g_slist_prepend (D.20223, vinfo);
        ctx->errors = D.20256;
      }
      <D.20251>:
      ctx->valid = 0;
      return;
      <D.20249>:
      valid_tables = MEM[(const guint64 *)ptr + 8B];
      count = 0;
      i = 0;
      goto <D.17648>;
      <D.17647>:
      D.20257 = valid_tables >> i;
      D.20258 = D.20257 & 1;
      if (D.20258 == 0) goto <D.20259>; else goto <D.20260>;
      <D.20259>:
      // predicted unlikely by continue predictor.
      goto <D.17644>;
      <D.20260>:
      D.20263 = i == 3;
      D.20264 = i == 5;
      D.20265 = D.20263 | D.20264;
      if (D.20265 != 0) goto <D.20261>; else goto <D.20266>;
      <D.20266>:
      D.20267 = i == 7;
      D.20268 = i == 19;
      D.20269 = D.20267 | D.20268;
      if (D.20269 != 0) goto <D.20261>; else goto <D.20270>;
      <D.20270>:
      if (i == 22) goto <D.20261>; else goto <D.20262>;
      <D.20261>:
      D.20219 = ctx->report_error;
      if (D.20219 != 0) goto <D.20271>; else goto <D.20272>;
      <D.20271>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20273 = monoeg_g_strdup_printf ("The metadata verifier doesn\'t support MS specific table %x", i);
        vinfo->info.message = D.20273;
        vinfo->exception_type = 3;
        D.20223 = ctx->errors;
        D.20274 = monoeg_g_slist_prepend (D.20223, vinfo);
        ctx->errors = D.20274;
      }
      <D.20272>:
      ctx->valid = 0;
      return;
      <D.20262>:
      i.17 = (unsigned int) i;
      D.20276 = i.17 + 4294967266;
      D.20277 = D.20276 <= 1;
      D.20278 = i > 44;
      D.20279 = D.20277 | D.20278;
      if (D.20279 != 0) goto <D.20280>; else goto <D.20281>;
      <D.20280>:
      D.20219 = ctx->report_error;
      if (D.20219 != 0) goto <D.20282>; else goto <D.20283>;
      <D.20282>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20284 = monoeg_g_strdup_printf ("Invalid table %x", i);
        vinfo->info.message = D.20284;
        vinfo->exception_type = 3;
        D.20223 = ctx->errors;
        D.20285 = monoeg_g_slist_prepend (D.20223, vinfo);
        ctx->errors = D.20285;
      }
      <D.20283>:
      ctx->valid = 0;
      return;
      <D.20281>:
      count = count + 1;
      <D.17644>:
      i = i + 1;
      <D.17648>:
      if (i <= 63) goto <D.17647>; else goto <D.17649>;
      <D.17649>:
      D.20216 = tables_area.size;
      D.20286 = count + 6;
      D.20287 = D.20286 * 4;
      if (D.20216 < D.20287) goto <D.20288>; else goto <D.20289>;
      <D.20288>:
      D.20219 = ctx->report_error;
      if (D.20219 != 0) goto <D.20290>; else goto <D.20291>;
      <D.20290>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20286 = count + 6;
        D.20287 = D.20286 * 4;
        D.20216 = tables_area.size;
        D.20292 = monoeg_g_strdup_printf ("Table schemata size (%d) too small to for decoding row counts (requires %d bytes)", D.20216, D.20287);
        vinfo->info.message = D.20292;
        vinfo->exception_type = 3;
        D.20223 = ctx->errors;
        D.20293 = monoeg_g_slist_prepend (D.20223, vinfo);
        ctx->errors = D.20293;
      }
      <D.20291>:
      ctx->valid = 0;
      return;
      <D.20289>:
      ptr = ptr + 24;
      i = 0;
      goto <D.17654>;
      <D.17653>:
      D.20257 = valid_tables >> i;
      D.20258 = D.20257 & 1;
      if (D.20258 != 0) goto <D.20294>; else goto <D.20295>;
      <D.20294>:
      {
        guint32 row_count;

        row_count = MEM[(const guint32 *)ptr];
        if (row_count > 16777215) goto <D.20296>; else goto <D.20297>;
        <D.20296>:
        D.20219 = ctx->report_error;
        if (D.20219 != 0) goto <D.20298>; else goto <D.20299>;
        <D.20298>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.20300 = monoeg_g_strdup_printf ("Invalid Table %d row count: %d. Mono only supports 16777215 rows", i, row_count);
          vinfo->info.message = D.20300;
          vinfo->exception_type = 3;
          D.20223 = ctx->errors;
          D.20301 = monoeg_g_slist_prepend (D.20223, vinfo);
          ctx->errors = D.20301;
        }
        <D.20299>:
        ctx->valid = 0;
        return;
        <D.20297>:
        ptr = ptr + 4;
      }
      <D.20295>:
      i = i + 1;
      <D.17654>:
      if (i <= 63) goto <D.17653>; else goto <D.17655>;
      <D.17655>:
    }
  finally
    {
      tables_area = {CLOBBER};
    }
}


mono_verifier_verify_table_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.20305;
  gboolean D.20308;
  _Bool D.20309;
  int D.20310;
  struct VerifyContext ctx;

  try
    {
      D.20305 = mono_verifier_is_enabled_for_image (image);
      if (D.20305 == 0) goto <D.20306>; else goto <D.20307>;
      <D.20306>:
      D.20308 = 1;
      return D.20308;
      <D.20307>:
      D.20309 = error_list != 0B;
      D.20310 = (int) D.20309;
      init_verify_context (&ctx, image, D.20310);
      ctx.stage = 2;
      verify_tables_data (&ctx);
      D.20308 = cleanup_context (&ctx, error_list);
      return D.20308;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


verify_tables_data (struct VerifyContext * ctx)
{
  struct MonoImage * D.20313;
  struct MonoStreamHeader * D.20314;
  unsigned char D.20315;
  unsigned int D.20316;
  <unnamed-unsigned:24> D.20317;
  unsigned int D.20318;
  unsigned int D.20319;
  int D.20324;
  gchar * D.20327;
  struct GSList * D.20328;
  struct GSList * D.20329;
  const char * D.20330;
  int D.20331;
  const char * D.20332;
  int D.20333;
  int D.20334;
  int D.20335;
  unsigned int D.20340;
  unsigned int D.20341;
  unsigned int D.20342;
  unsigned int D.20343;
  gchar * D.20344;
  struct GSList * D.20345;
  int D.20346;
  struct OffsetAndSize tables_area;
  guint32 size;
  guint32 tables_offset;
  int i;

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

        D.20313 = ctx->image;
        table = &D.20313->tables[i];
        D.20315 = table->row_size;
        D.20316 = (unsigned int) D.20315;
        D.20317 = table->rows;
        D.20318 = (unsigned int) D.20317;
        D.20319 = D.20316 * D.20318;
        tmp_size = D.20319 + size;
        if (tmp_size < size) goto <D.20320>; else goto <D.20321>;
        <D.20320>:
        size = 0;
        goto <D.19118>;
        <D.20321>:
        size = tmp_size;
      }
      i = i + 1;
      <D.19120>:
      if (i <= 44) goto <D.19119>; else goto <D.19118>;
      <D.19118>:
      if (size == 0) goto <D.20322>; else goto <D.20323>;
      <D.20322>:
      D.20324 = ctx->report_error;
      if (D.20324 != 0) goto <D.20325>; else goto <D.20326>;
      <D.20325>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20327 = monoeg_g_strdup_printf ("table space is either empty or overflowed");
        vinfo->info.message = D.20327;
        vinfo->exception_type = 3;
        D.20328 = ctx->errors;
        D.20329 = monoeg_g_slist_prepend (D.20328, vinfo);
        ctx->errors = D.20329;
      }
      <D.20326>:
      ctx->valid = 0;
      return;
      <D.20323>:
      D.20313 = ctx->image;
      D.20330 = D.20313->tables_base;
      D.20331 = (int) D.20330;
      D.20332 = ctx->data;
      D.20333 = (int) D.20332;
      D.20334 = D.20331 - D.20333;
      tables_offset = (guint32) D.20334;
      D.20335 = bounds_check_offset (&tables_area, tables_offset, size);
      if (D.20335 == 0) goto <D.20336>; else goto <D.20337>;
      <D.20336>:
      D.20324 = ctx->report_error;
      if (D.20324 != 0) goto <D.20338>; else goto <D.20339>;
      <D.20338>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20340 = tables_area.size;
        D.20341 = tables_area.offset;
        D.20342 = D.20341 - tables_offset;
        D.20343 = D.20340 + D.20342;
        D.20344 = monoeg_g_strdup_printf ("Tables data require %d bytes but the only %d are available in the #~ stream", size, D.20343);
        vinfo->info.message = D.20344;
        vinfo->exception_type = 3;
        D.20328 = ctx->errors;
        D.20345 = monoeg_g_slist_prepend (D.20328, vinfo);
        ctx->errors = D.20345;
      }
      <D.20339>:
      ctx->valid = 0;
      return;
      <D.20337>:
      verify_module_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20347>; else goto <D.20348>;
      <D.20347>:
      return;
      <D.20348>:
      verify_typedef_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20349>; else goto <D.20350>;
      <D.20349>:
      return;
      <D.20350>:
      verify_field_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20351>; else goto <D.20352>;
      <D.20351>:
      return;
      <D.20352>:
      verify_method_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20353>; else goto <D.20354>;
      <D.20353>:
      return;
      <D.20354>:
      verify_param_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20355>; else goto <D.20356>;
      <D.20355>:
      return;
      <D.20356>:
      verify_interfaceimpl_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20357>; else goto <D.20358>;
      <D.20357>:
      return;
      <D.20358>:
      verify_memberref_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20359>; else goto <D.20360>;
      <D.20359>:
      return;
      <D.20360>:
      verify_constant_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20361>; else goto <D.20362>;
      <D.20361>:
      return;
      <D.20362>:
      verify_cattr_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20363>; else goto <D.20364>;
      <D.20363>:
      return;
      <D.20364>:
      verify_field_marshal_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20365>; else goto <D.20366>;
      <D.20365>:
      return;
      <D.20366>:
      verify_decl_security_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20367>; else goto <D.20368>;
      <D.20367>:
      return;
      <D.20368>:
      verify_class_layout_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20369>; else goto <D.20370>;
      <D.20369>:
      return;
      <D.20370>:
      verify_field_layout_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20371>; else goto <D.20372>;
      <D.20371>:
      return;
      <D.20372>:
      verify_standalonesig_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20373>; else goto <D.20374>;
      <D.20373>:
      return;
      <D.20374>:
      verify_eventmap_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20375>; else goto <D.20376>;
      <D.20375>:
      return;
      <D.20376>:
      verify_event_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20377>; else goto <D.20378>;
      <D.20377>:
      return;
      <D.20378>:
      verify_propertymap_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20379>; else goto <D.20380>;
      <D.20379>:
      return;
      <D.20380>:
      verify_property_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20381>; else goto <D.20382>;
      <D.20381>:
      return;
      <D.20382>:
      verify_methodimpl_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20383>; else goto <D.20384>;
      <D.20383>:
      return;
      <D.20384>:
      verify_moduleref_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20385>; else goto <D.20386>;
      <D.20385>:
      return;
      <D.20386>:
      verify_typespec_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20387>; else goto <D.20388>;
      <D.20387>:
      return;
      <D.20388>:
      verify_implmap_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20389>; else goto <D.20390>;
      <D.20389>:
      return;
      <D.20390>:
      verify_fieldrva_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20391>; else goto <D.20392>;
      <D.20391>:
      return;
      <D.20392>:
      verify_assembly_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20393>; else goto <D.20394>;
      <D.20393>:
      return;
      <D.20394>:
      verify_assemblyref_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20395>; else goto <D.20396>;
      <D.20395>:
      return;
      <D.20396>:
      verify_file_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20397>; else goto <D.20398>;
      <D.20397>:
      return;
      <D.20398>:
      verify_exportedtype_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20399>; else goto <D.20400>;
      <D.20399>:
      return;
      <D.20400>:
      verify_manifest_resource_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20401>; else goto <D.20402>;
      <D.20401>:
      return;
      <D.20402>:
      verify_nested_class_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20403>; else goto <D.20404>;
      <D.20403>:
      return;
      <D.20404>:
      verify_generic_param_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20405>; else goto <D.20406>;
      <D.20405>:
      return;
      <D.20406>:
      verify_method_spec_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20407>; else goto <D.20408>;
      <D.20407>:
      return;
      <D.20408>:
      verify_generic_param_constraint_table (ctx);
      D.20346 = ctx->valid;
      if (D.20346 == 0) goto <D.20409>; else goto <D.20410>;
      <D.20409>:
      return;
      <D.20410>:
      verify_tables_data_global_constraints (ctx);
    }
  finally
    {
      tables_area = {CLOBBER};
    }
}


get_metadata_stream (struct VerifyContext * ctx, struct MonoStreamHeader * header)
{
  const char * D.20415;
  int D.20416;
  const char * D.20417;
  int D.20418;
  int D.20419;
  unsigned int D.20420;
  unsigned int D.20421;
  struct OffsetAndSize res;

  try
    {
      D.20415 = header->data;
      D.20416 = (int) D.20415;
      D.20417 = ctx->data;
      D.20418 = (int) D.20417;
      D.20419 = D.20416 - D.20418;
      D.20420 = (unsigned int) D.20419;
      res.offset = D.20420;
      D.20421 = header->size;
      res.size = D.20421;
      <retval> = res;
      return <retval>;
    }
  finally
    {
      res = {CLOBBER};
    }
}


bounds_check_offset (struct OffsetAndSize * off, guint32 offset, guint32 size)
{
  unsigned int D.20424;
  gboolean D.20427;
  unsigned int D.20428;
  unsigned int D.20431;
  unsigned int D.20432;
  _Bool D.20433;

  D.20424 = off->offset;
  if (D.20424 > offset) goto <D.20425>; else goto <D.20426>;
  <D.20425>:
  D.20427 = 0;
  return D.20427;
  <D.20426>:
  D.20428 = off->size;
  if (D.20428 < size) goto <D.20429>; else goto <D.20430>;
  <D.20429>:
  D.20427 = 0;
  return D.20427;
  <D.20430>:
  D.20431 = offset + size;
  D.20424 = off->offset;
  D.20428 = off->size;
  D.20432 = D.20424 + D.20428;
  D.20433 = D.20431 <= D.20432;
  D.20427 = (gboolean) D.20433;
  return D.20427;
}


verify_module_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.20435;
  unsigned int D.20436;
  unsigned int D.20437;
  int D.20440;
  <unnamed-unsigned:24> D.20443;
  int D.20444;
  gchar * D.20445;
  struct GSList * D.20446;
  struct GSList * D.20447;
  unsigned int D.20448;
  int D.20449;
  gchar * D.20454;
  struct GSList * D.20455;
  unsigned int D.20456;
  int D.20457;
  gchar * D.20462;
  struct GSList * D.20463;
  unsigned int D.20464;
  gchar * D.20469;
  struct GSList * D.20470;
  unsigned int D.20471;
  gchar * D.20476;
  struct GSList * D.20477;
  struct MonoTableInfo * table;
  guint32 data[5];

  try
    {
      D.20435 = ctx->image;
      table = &D.20435->tables[0];
      D.20436 = BIT_FIELD_REF <*table, 32, 32>;
      D.20437 = D.20436 & 16777215;
      if (D.20437 != 1) goto <D.20438>; else goto <D.20439>;
      <D.20438>:
      D.20440 = ctx->report_error;
      if (D.20440 != 0) goto <D.20441>; else goto <D.20442>;
      <D.20441>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20443 = table->rows;
        D.20444 = (int) D.20443;
        D.20445 = monoeg_g_strdup_printf ("Module table must have exactly one row, but have %d", D.20444);
        vinfo->info.message = D.20445;
        vinfo->exception_type = 3;
        D.20446 = ctx->errors;
        D.20447 = monoeg_g_slist_prepend (D.20446, vinfo);
        ctx->errors = D.20447;
      }
      <D.20442>:
      ctx->valid = 0;
      return;
      <D.20439>:
      mono_metadata_decode_row (table, 0, &data, 5);
      D.20448 = data[1];
      D.20449 = is_valid_non_empty_string (ctx, D.20448);
      if (D.20449 == 0) goto <D.20450>; else goto <D.20451>;
      <D.20450>:
      D.20440 = ctx->report_error;
      if (D.20440 != 0) goto <D.20452>; else goto <D.20453>;
      <D.20452>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20448 = data[1];
        D.20454 = monoeg_g_strdup_printf ("Module has an invalid name, string index 0x%08x", D.20448);
        vinfo->info.message = D.20454;
        vinfo->exception_type = 3;
        D.20446 = ctx->errors;
        D.20455 = monoeg_g_slist_prepend (D.20446, vinfo);
        ctx->errors = D.20455;
      }
      <D.20453>:
      ctx->valid = 0;
      return;
      <D.20451>:
      D.20456 = data[2];
      D.20457 = is_valid_guid (ctx, D.20456);
      if (D.20457 == 0) goto <D.20458>; else goto <D.20459>;
      <D.20458>:
      D.20440 = ctx->report_error;
      if (D.20440 != 0) goto <D.20460>; else goto <D.20461>;
      <D.20460>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20456 = data[2];
        D.20462 = monoeg_g_strdup_printf ("Module has an invalid Mvid, guid index %x", D.20456);
        vinfo->info.message = D.20462;
        vinfo->exception_type = 3;
        D.20446 = ctx->errors;
        D.20463 = monoeg_g_slist_prepend (D.20446, vinfo);
        ctx->errors = D.20463;
      }
      <D.20461>:
      ctx->valid = 0;
      return;
      <D.20459>:
      D.20464 = data[3];
      if (D.20464 != 0) goto <D.20465>; else goto <D.20466>;
      <D.20465>:
      D.20440 = ctx->report_error;
      if (D.20440 != 0) goto <D.20467>; else goto <D.20468>;
      <D.20467>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20464 = data[3];
        D.20469 = monoeg_g_strdup_printf ("Module has a non zero Enc field %x", D.20464);
        vinfo->info.message = D.20469;
        vinfo->exception_type = 3;
        D.20446 = ctx->errors;
        D.20470 = monoeg_g_slist_prepend (D.20446, vinfo);
        ctx->errors = D.20470;
      }
      <D.20468>:
      ctx->valid = 0;
      return;
      <D.20466>:
      D.20471 = data[4];
      if (D.20471 != 0) goto <D.20472>; else goto <D.20473>;
      <D.20472>:
      D.20440 = ctx->report_error;
      if (D.20440 != 0) goto <D.20474>; else goto <D.20475>;
      <D.20474>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20471 = data[4];
        D.20476 = monoeg_g_strdup_printf ("Module has a non zero EncBase field %x", D.20471);
        vinfo->info.message = D.20476;
        vinfo->exception_type = 3;
        D.20446 = ctx->errors;
        D.20477 = monoeg_g_slist_prepend (D.20446, vinfo);
        ctx->errors = D.20477;
      }
      <D.20475>:
      ctx->valid = 0;
      return;
      <D.20473>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


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

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


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

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


is_valid_string_full_with_image (struct MonoImage * image, guint32 offset, gboolean allow_empty)
{
  const char * D.20486;
  int D.20487;
  char * D.20488;
  int D.20489;
  int D.20490;
  gboolean D.20493;
  unsigned int D.20494;
  unsigned int data.18;
  unsigned int D.20498;
  long int D.20499;
  const gchar * D.20500;
  int D.20501;
  int iftmp.19;
  long int length.20;
  guint32 heap_offset;
  guint32 heap_size;
  glong length;
  const char * data;

  try
    {
      D.20486 = image->heap_strings.data;
      D.20487 = (int) D.20486;
      D.20488 = image->raw_data;
      D.20489 = (int) D.20488;
      D.20490 = D.20487 - D.20489;
      heap_offset = (guint32) D.20490;
      heap_size = image->heap_strings.size;
      D.20488 = image->raw_data;
      data = D.20488 + heap_offset;
      if (offset >= heap_size) goto <D.20491>; else goto <D.20492>;
      <D.20491>:
      D.20493 = 0;
      return D.20493;
      <D.20492>:
      D.20494 = ~offset;
      data.18 = (unsigned int) data;
      if (D.20494 < data.18) goto <D.20496>; else goto <D.20497>;
      <D.20496>:
      D.20493 = 0;
      return D.20493;
      <D.20497>:
      D.20498 = heap_size - offset;
      D.20499 = (long int) D.20498;
      D.20500 = data + offset;
      D.20501 = mono_utf8_validate_and_len_with_bounds (D.20500, D.20499, &length, 0B);
      if (D.20501 == 0) goto <D.20502>; else goto <D.20503>;
      <D.20502>:
      D.20493 = 0;
      return D.20493;
      <D.20503>:
      if (allow_empty != 0) goto <D.20505>; else goto <D.20508>;
      <D.20508>:
      length.20 = length;
      if (length.20 > 0) goto <D.20505>; else goto <D.20506>;
      <D.20505>:
      iftmp.19 = 1;
      goto <D.20507>;
      <D.20506>:
      iftmp.19 = 0;
      <D.20507>:
      D.20493 = iftmp.19;
      return D.20493;
    }
  finally
    {
      length = {CLOBBER};
    }
}


is_valid_guid (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.20512;
  struct MonoStreamHeader * D.20513;
  gboolean D.20514;
  int iftmp.21;
  unsigned int D.20518;
  unsigned int D.20520;
  struct OffsetAndSize guids;

  try
    {
      D.20512 = ctx->image;
      D.20513 = &D.20512->heap_guid;
      guids = get_metadata_stream (ctx, D.20513); [return slot optimization]
      D.20518 = guids.size;
      if (D.20518 > 7) goto <D.20519>; else goto <D.20516>;
      <D.20519>:
      D.20518 = guids.size;
      D.20520 = D.20518 + 4294967288;
      if (D.20520 >= offset) goto <D.20521>; else goto <D.20516>;
      <D.20521>:
      iftmp.21 = 1;
      goto <D.20517>;
      <D.20516>:
      iftmp.21 = 0;
      <D.20517>:
      D.20514 = iftmp.21;
      return D.20514;
    }
  finally
    {
      guids = {CLOBBER};
    }
}


verify_typedef_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.20524;
  unsigned int D.20525;
  unsigned int D.20526;
  int D.20529;
  gchar * D.20532;
  struct GSList * D.20533;
  struct GSList * D.20534;
  unsigned int D.20535;
  unsigned int D.20536;
  gchar * D.20541;
  struct GSList * D.20542;
  unsigned int D.20543;
  gchar * D.20548;
  struct GSList * D.20549;
  unsigned int D.20550;
  gchar * D.20555;
  struct GSList * D.20556;
  unsigned int D.20557;
  gchar * D.20562;
  struct GSList * D.20563;
  unsigned int D.20564;
  unsigned int D.20565;
  gchar * D.20570;
  struct GSList * D.20571;
  unsigned int D.20574;
  int D.20576;
  gchar * D.20579;
  struct GSList * D.20580;
  unsigned int D.20581;
  int D.20584;
  gchar * D.20589;
  struct GSList * D.20590;
  unsigned int D.20591;
  int D.20594;
  gchar * D.20599;
  struct GSList * D.20600;
  unsigned int D.20603;
  gchar * D.20608;
  struct GSList * D.20609;
  unsigned int D.20610;
  int D.20613;
  unsigned int D.20614;
  int D.20615;
  gchar * D.20620;
  struct GSList * D.20621;
  unsigned int D.20622;
  gchar * D.20627;
  struct GSList * D.20628;
  <unnamed-unsigned:24> D.20629;
  int D.20630;
  int D.20631;
  unsigned int D.20632;
  gchar * D.20637;
  struct GSList * D.20638;
  gchar * D.20643;
  struct GSList * D.20644;
  unsigned int D.20645;
  gchar * D.20650;
  struct GSList * D.20651;
  <unnamed-unsigned:24> D.20652;
  int D.20653;
  int D.20654;
  unsigned int D.20655;
  gchar * D.20660;
  struct GSList * D.20661;
  gchar * D.20666;
  struct GSList * D.20667;
  <unnamed-unsigned:24> D.20668;
  int D.20669;
  struct MonoTableInfo * table;
  guint32 data[6];
  guint32 fieldlist;
  guint32 methodlist;
  guint32 visibility;
  int i;

  try
    {
      D.20524 = ctx->image;
      table = &D.20524->tables[2];
      fieldlist = 1;
      methodlist = 1;
      D.20525 = BIT_FIELD_REF <*table, 32, 32>;
      D.20526 = D.20525 & 16777215;
      if (D.20526 == 0) goto <D.20527>; else goto <D.20528>;
      <D.20527>:
      D.20529 = ctx->report_error;
      if (D.20529 != 0) goto <D.20530>; else goto <D.20531>;
      <D.20530>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20532 = monoeg_g_strdup_printf ("Typedef table must have exactly at least one row");
        vinfo->info.message = D.20532;
        vinfo->exception_type = 3;
        D.20533 = ctx->errors;
        D.20534 = monoeg_g_slist_prepend (D.20533, vinfo);
        ctx->errors = D.20534;
      }
      <D.20531>:
      ctx->valid = 0;
      return;
      <D.20528>:
      i = 0;
      goto <D.18407>;
      <D.18406>:
      mono_metadata_decode_row (table, i, &data, 6);
      D.20535 = data[0];
      D.20536 = D.20535 & 4280861248;
      if (D.20536 != 0) goto <D.20537>; else goto <D.20538>;
      <D.20537>:
      D.20529 = ctx->report_error;
      if (D.20529 != 0) goto <D.20539>; else goto <D.20540>;
      <D.20539>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20535 = data[0];
        D.20541 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid flags field 0x%08x", i, D.20535);
        vinfo->info.message = D.20541;
        vinfo->exception_type = 3;
        D.20533 = ctx->errors;
        D.20542 = monoeg_g_slist_prepend (D.20533, vinfo);
        ctx->errors = D.20542;
      }
      <D.20540>:
      ctx->valid = 0;
      return;
      <D.20538>:
      D.20535 = data[0];
      D.20543 = D.20535 & 24;
      if (D.20543 == 24) goto <D.20544>; else goto <D.20545>;
      <D.20544>:
      D.20529 = ctx->report_error;
      if (D.20529 != 0) goto <D.20546>; else goto <D.20547>;
      <D.20546>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20548 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid class layout 0x18", i);
        vinfo->info.message = D.20548;
        vinfo->exception_type = 3;
        D.20533 = ctx->errors;
        D.20549 = monoeg_g_slist_prepend (D.20533, vinfo);
        ctx->errors = D.20549;
      }
      <D.20547>:
      ctx->valid = 0;
      return;
      <D.20545>:
      D.20535 = data[0];
      D.20550 = D.20535 & 196608;
      if (D.20550 == 196608) goto <D.20551>; else goto <D.20552>;
      <D.20551>:
      D.20529 = ctx->report_error;
      if (D.20529 != 0) goto <D.20553>; else goto <D.20554>;
      <D.20553>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20555 = monoeg_g_strdup_printf ("Invalid typedef row %d mono doesn\'t support custom string format", i);
        vinfo->info.message = D.20555;
        vinfo->exception_type = 3;
        D.20533 = ctx->errors;
        D.20556 = monoeg_g_slist_prepend (D.20533, vinfo);
        ctx->errors = D.20556;
      }
      <D.20554>:
      ctx->valid = 0;
      return;
      <D.20552>:
      D.20535 = data[0];
      D.20557 = D.20535 & 12582912;
      if (D.20557 != 0) goto <D.20558>; else goto <D.20559>;
      <D.20558>:
      D.20529 = ctx->report_error;
      if (D.20529 != 0) goto <D.20560>; else goto <D.20561>;
      <D.20560>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20562 = monoeg_g_strdup_printf ("Invalid typedef row %d mono doesn\'t support custom string format", i);
        vinfo->info.message = D.20562;
        vinfo->exception_type = 3;
        D.20533 = ctx->errors;
        D.20563 = monoeg_g_slist_prepend (D.20533, vinfo);
        ctx->errors = D.20563;
      }
      <D.20561>:
      ctx->valid = 0;
      return;
      <D.20559>:
      D.20564 = BIT_FIELD_REF <data, 32, 0>;
      D.20565 = D.20564 & 160;
      if (D.20565 == 32) goto <D.20566>; else goto <D.20567>;
      <D.20566>:
      D.20529 = ctx->report_error;
      if (D.20529 != 0) goto <D.20568>; else goto <D.20569>;
      <D.20568>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20570 = monoeg_g_strdup_printf ("Invalid typedef row %d for interface type must be abstract", i);
        vinfo->info.message = D.20570;
        vinfo->exception_type = 3;
        D.20533 = ctx->errors;
        D.20571 = monoeg_g_slist_prepend (D.20533, vinfo);
        ctx->errors = D.20571;
      }
      <D.20569>:
      ctx->valid = 0;
      return;
      <D.20567>:
      D.20574 = data[1];
      if (D.20574 == 0) goto <D.20572>; else goto <D.20575>;
      <D.20575>:
      D.20574 = data[1];
      D.20576 = is_valid_non_empty_string (ctx, D.20574);
      if (D.20576 == 0) goto <D.20572>; else goto <D.20573>;
      <D.20572>:
      D.20529 = ctx->report_error;
      if (D.20529 != 0) goto <D.20577>; else goto <D.20578>;
      <D.20577>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20574 = data[1];
        D.20579 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid name token %08x", i, D.20574);
        vinfo->info.message = D.20579;
        vinfo->exception_type = 3;
        D.20533 = ctx->errors;
        D.20580 = monoeg_g_slist_prepend (D.20533, vinfo);
        ctx->errors = D.20580;
      }
      <D.20578>:
      ctx->valid = 0;
      return;
      <D.20573>:
      D.20581 = data[2];
      if (D.20581 != 0) goto <D.20582>; else goto <D.20583>;
      <D.20582>:
      D.20581 = data[2];
      D.20584 = is_valid_non_empty_string (ctx, D.20581);
      if (D.20584 == 0) goto <D.20585>; else goto <D.20586>;
      <D.20585>:
      D.20529 = ctx->report_error;
      if (D.20529 != 0) goto <D.20587>; else goto <D.20588>;
      <D.20587>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20581 = data[2];
        D.20589 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid namespace token %08x", i, D.20581);
        vinfo->info.message = D.20589;
        vinfo->exception_type = 3;
        D.20533 = ctx->errors;
        D.20590 = monoeg_g_slist_prepend (D.20533, vinfo);
        ctx->errors = D.20590;
      }
      <D.20588>:
      ctx->valid = 0;
      return;
      <D.20586>:
      <D.20583>:
      D.20591 = data[3];
      if (D.20591 != 0) goto <D.20592>; else goto <D.20593>;
      <D.20592>:
      D.20591 = data[3];
      D.20594 = is_valid_coded_index (ctx, 0, D.20591);
      if (D.20594 == 0) goto <D.20595>; else goto <D.20596>;
      <D.20595>:
      D.20529 = ctx->report_error;
      if (D.20529 != 0) goto <D.20597>; else goto <D.20598>;
      <D.20597>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20591 = data[3];
        D.20599 = monoeg_g_strdup_printf ("Invalid typedef row %d extend field coded index 0x%08x", i, D.20591);
        vinfo->info.message = D.20599;
        vinfo->exception_type = 3;
        D.20533 = ctx->errors;
        D.20600 = monoeg_g_slist_prepend (D.20533, vinfo);
        ctx->errors = D.20600;
      }
      <D.20598>:
      ctx->valid = 0;
      return;
      <D.20596>:
      <D.20593>:
      D.20591 = data[3];
      if (D.20591 != 0) goto <D.20601>; else goto <D.20602>;
      <D.20601>:
      D.20591 = data[3];
      D.20603 = get_coded_index_token (0, D.20591);
      if (D.20603 == 0) goto <D.20604>; else goto <D.20605>;
      <D.20604>:
      D.20529 = ctx->report_error;
      if (D.20529 != 0) goto <D.20606>; else goto <D.20607>;
      <D.20606>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20591 = data[3];
        D.20608 = monoeg_g_strdup_printf ("Invalid typedef row %d zero coded extend field coded index 0x%08x", i, D.20591);
        vinfo->info.message = D.20608;
        vinfo->exception_type = 3;
        D.20533 = ctx->errors;
        D.20609 = monoeg_g_slist_prepend (D.20533, vinfo);
        ctx->errors = D.20609;
      }
      <D.20607>:
      ctx->valid = 0;
      return;
      <D.20605>:
      <D.20602>:
      D.20535 = data[0];
      visibility = D.20535 & 7;
      D.20610 = visibility + 4294967294;
      if (D.20610 <= 5) goto <D.20611>; else goto <D.20612>;
      <D.20611>:
      D.20613 = i + 1;
      D.20614 = (unsigned int) D.20613;
      D.20615 = search_sorted_table (ctx, 41, 0, D.20614);
      if (D.20615 == -1) goto <D.20616>; else goto <D.20617>;
      <D.20616>:
      D.20529 = ctx->report_error;
      if (D.20529 != 0) goto <D.20618>; else goto <D.20619>;
      <D.20618>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20620 = monoeg_g_strdup_printf ("Invalid typedef row %d has nested visibility but no rows in the NestedClass table", i);
        vinfo->info.message = D.20620;
        vinfo->exception_type = 3;
        D.20533 = ctx->errors;
        D.20621 = monoeg_g_slist_prepend (D.20533, vinfo);
        ctx->errors = D.20621;
      }
      <D.20619>:
      ctx->valid = 0;
      return;
      <D.20617>:
      <D.20612>:
      D.20622 = data[4];
      if (D.20622 == 0) goto <D.20623>; else goto <D.20624>;
      <D.20623>:
      D.20529 = ctx->report_error;
      if (D.20529 != 0) goto <D.20625>; else goto <D.20626>;
      <D.20625>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20627 = monoeg_g_strdup_printf ("Invalid typedef row %d FieldList be be >= 1", i);
        vinfo->info.message = D.20627;
        vinfo->exception_type = 3;
        D.20533 = ctx->errors;
        D.20628 = monoeg_g_slist_prepend (D.20533, vinfo);
        ctx->errors = D.20628;
      }
      <D.20626>:
      ctx->valid = 0;
      return;
      <D.20624>:
      D.20622 = data[4];
      D.20524 = ctx->image;
      D.20629 = D.20524->tables[4].rows;
      D.20630 = (int) D.20629;
      D.20631 = D.20630 + 1;
      D.20632 = (unsigned int) D.20631;
      if (D.20622 > D.20632) goto <D.20633>; else goto <D.20634>;
      <D.20633>:
      D.20529 = ctx->report_error;
      if (D.20529 != 0) goto <D.20635>; else goto <D.20636>;
      <D.20635>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20622 = data[4];
        D.20637 = monoeg_g_strdup_printf ("Invalid typedef row %d FieldList rowid 0x%08x is out of range", i, D.20622);
        vinfo->info.message = D.20637;
        vinfo->exception_type = 3;
        D.20533 = ctx->errors;
        D.20638 = monoeg_g_slist_prepend (D.20533, vinfo);
        ctx->errors = D.20638;
      }
      <D.20636>:
      ctx->valid = 0;
      return;
      <D.20634>:
      D.20622 = data[4];
      if (D.20622 < fieldlist) goto <D.20639>; else goto <D.20640>;
      <D.20639>:
      D.20529 = ctx->report_error;
      if (D.20529 != 0) goto <D.20641>; else goto <D.20642>;
      <D.20641>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20622 = data[4];
        D.20643 = monoeg_g_strdup_printf ("Invalid typedef row %d FieldList rowid 0x%08x can\'t be smaller than of previous row 0x%08x", i, D.20622, fieldlist);
        vinfo->info.message = D.20643;
        vinfo->exception_type = 3;
        D.20533 = ctx->errors;
        D.20644 = monoeg_g_slist_prepend (D.20533, vinfo);
        ctx->errors = D.20644;
      }
      <D.20642>:
      ctx->valid = 0;
      return;
      <D.20640>:
      D.20645 = data[5];
      if (D.20645 == 0) goto <D.20646>; else goto <D.20647>;
      <D.20646>:
      D.20529 = ctx->report_error;
      if (D.20529 != 0) goto <D.20648>; else goto <D.20649>;
      <D.20648>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20650 = monoeg_g_strdup_printf ("Invalid typedef row %d MethodList be be >= 1", i);
        vinfo->info.message = D.20650;
        vinfo->exception_type = 3;
        D.20533 = ctx->errors;
        D.20651 = monoeg_g_slist_prepend (D.20533, vinfo);
        ctx->errors = D.20651;
      }
      <D.20649>:
      ctx->valid = 0;
      return;
      <D.20647>:
      D.20645 = data[5];
      D.20524 = ctx->image;
      D.20652 = D.20524->tables[6].rows;
      D.20653 = (int) D.20652;
      D.20654 = D.20653 + 1;
      D.20655 = (unsigned int) D.20654;
      if (D.20645 > D.20655) goto <D.20656>; else goto <D.20657>;
      <D.20656>:
      D.20529 = ctx->report_error;
      if (D.20529 != 0) goto <D.20658>; else goto <D.20659>;
      <D.20658>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20645 = data[5];
        D.20660 = monoeg_g_strdup_printf ("Invalid typedef row %d MethodList rowid 0x%08x is out of range", i, D.20645);
        vinfo->info.message = D.20660;
        vinfo->exception_type = 3;
        D.20533 = ctx->errors;
        D.20661 = monoeg_g_slist_prepend (D.20533, vinfo);
        ctx->errors = D.20661;
      }
      <D.20659>:
      ctx->valid = 0;
      return;
      <D.20657>:
      D.20645 = data[5];
      if (D.20645 < methodlist) goto <D.20662>; else goto <D.20663>;
      <D.20662>:
      D.20529 = ctx->report_error;
      if (D.20529 != 0) goto <D.20664>; else goto <D.20665>;
      <D.20664>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20645 = data[5];
        D.20666 = monoeg_g_strdup_printf ("Invalid typedef row %d MethodList rowid 0x%08x can\'t be smaller than of previous row 0x%08x", i, D.20645, methodlist);
        vinfo->info.message = D.20666;
        vinfo->exception_type = 3;
        D.20533 = ctx->errors;
        D.20667 = monoeg_g_slist_prepend (D.20533, vinfo);
        ctx->errors = D.20667;
      }
      <D.20665>:
      ctx->valid = 0;
      return;
      <D.20663>:
      fieldlist = data[4];
      methodlist = data[5];
      i = i + 1;
      <D.18407>:
      D.20668 = table->rows;
      D.20669 = (int) D.20668;
      if (D.20669 > i) goto <D.18406>; else goto <D.18408>;
      <D.18408>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


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

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


is_valid_coded_index_with_image (struct MonoImage * image, int token_kind, guint32 coded_token)
{
  int token_kind.22;
  unsigned char D.20677;
  int token_kind.23;
  unsigned char D.20679;
  int bits.24;
  int D.20681;
  int D.20682;
  unsigned int D.20683;
  gboolean D.20686;
  unsigned int token_kind.25;
  unsigned int D.20688;
  unsigned char D.20689;
  <unnamed-unsigned:24> D.20692;
  unsigned int D.20693;
  _Bool D.20694;
  guint32 bits;
  guint32 table_count;
  guint32 table;
  guint32 token;

  token_kind.22 = token_kind;
  token_kind = token_kind.22 + 1;
  D.20677 = coded_index_desc[token_kind.22];
  bits = (guint32) D.20677;
  token_kind.23 = token_kind;
  token_kind = token_kind.23 + 1;
  D.20679 = coded_index_desc[token_kind.23];
  table_count = (guint32) D.20679;
  bits.24 = (int) bits;
  D.20681 = 1 << bits.24;
  D.20682 = D.20681 + -1;
  D.20683 = (unsigned int) D.20682;
  table = D.20683 & coded_token;
  bits.24 = (int) bits;
  token = coded_token >> bits.24;
  if (table >= table_count) goto <D.20684>; else goto <D.20685>;
  <D.20684>:
  D.20686 = 0;
  return D.20686;
  <D.20685>:
  token_kind.25 = (unsigned int) token_kind;
  D.20688 = token_kind.25 + table;
  D.20689 = coded_index_desc[D.20688];
  table = (guint32) D.20689;
  if (table == 255) goto <D.20690>; else goto <D.20691>;
  <D.20690>:
  D.20686 = 0;
  return D.20686;
  <D.20691>:
  D.20692 = image->tables[table].rows;
  D.20693 = (unsigned int) D.20692;
  D.20694 = D.20693 >= token;
  D.20686 = (gboolean) D.20694;
  return D.20686;
}


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

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


search_sorted_table (struct VerifyContext * ctx, int table, int column, guint32 coded_token)
{
  struct MonoImage * D.20700;
  unsigned int D.20701;
  unsigned int D.20702;
  unsigned char D.20703;
  unsigned int D.20704;
  <unnamed-unsigned:24> D.20705;
  unsigned int D.20706;
  int D.20709;
  int res.27;
  int base.28;
  int D.20712;
  int D.20713;
  struct MonoTableInfo * tinfo;
  struct RowLocator locator;
  const char * res;
  const char * base;

  try
    {
      D.20700 = ctx->image;
      tinfo = &D.20700->tables[table];
      locator.token = coded_token;
      D.20701 = get_col_offset (ctx, table, column);
      locator.col_offset = D.20701;
      D.20702 = get_col_size (ctx, table, column);
      locator.col_size = D.20702;
      locator.table = tinfo;
      base = tinfo->base;
      D.20703 = tinfo->row_size;
      D.20704 = (unsigned int) D.20703;
      D.20705 = tinfo->rows;
      D.20706 = (unsigned int) D.20705;
      res = mono_binary_search (&locator, base, D.20706, D.20704, token_locator);
      if (res == 0B) goto <D.20707>; else goto <D.20708>;
      <D.20707>:
      D.20709 = -1;
      return D.20709;
      <D.20708>:
      res.27 = (int) res;
      base.28 = (int) base;
      D.20712 = res.27 - base.28;
      D.20703 = tinfo->row_size;
      D.20713 = (int) D.20703;
      D.20709 = D.20712 / D.20713;
      return D.20709;
    }
  finally
    {
      locator = {CLOBBER};
    }
}


token_locator (const void * a, const void * b)
{
  const unsigned int iftmp.29;
  unsigned int D.20717;
  unsigned int D.20720;
  const guint16 * D.20721;
  short unsigned int D.20722;
  const guint32 * D.20724;
  int D.20725;
  unsigned int D.20726;
  int D.20727;
  int token.30;
  struct RowLocator * loc;
  const unsigned char * row;
  guint32 token;

  loc = a;
  row = b;
  D.20717 = loc->col_size;
  if (D.20717 == 2) goto <D.20718>; else goto <D.20719>;
  <D.20718>:
  D.20720 = loc->col_offset;
  D.20721 = row + D.20720;
  D.20722 = *D.20721;
  iftmp.29 = (const unsigned int) D.20722;
  goto <D.20723>;
  <D.20719>:
  D.20720 = loc->col_offset;
  D.20724 = row + D.20720;
  iftmp.29 = *D.20724;
  <D.20723>:
  token = iftmp.29;
  D.20726 = loc->token;
  D.20727 = (int) D.20726;
  token.30 = (int) token;
  D.20725 = D.20727 - token.30;
  return D.20725;
}


get_col_offset (struct VerifyContext * ctx, int table, int column)
{
  struct MonoImage * D.20730;
  int D.20731;
  unsigned int D.20732;
  unsigned int D.20733;
  unsigned int D.20734;
  int column.31;
  guint32 D.20736;
  guint32 bitfield;
  guint32 offset;

  D.20730 = ctx->image;
  bitfield = D.20730->tables[table].size_bitfield;
  offset = 0;
  goto <D.17664>;
  <D.17663>:
  D.20731 = column * 2;
  D.20732 = bitfield >> D.20731;
  D.20733 = D.20732 & 3;
  D.20734 = D.20733 + offset;
  offset = D.20734 + 1;
  <D.17664>:
  column.31 = column;
  column = column.31 + -1;
  if (column.31 > 0) goto <D.17663>; else goto <D.17665>;
  <D.17665>:
  D.20736 = offset;
  return D.20736;
}


get_col_size (struct VerifyContext * ctx, int table, int column)
{
  guint32 D.20738;
  struct MonoImage * D.20739;
  unsigned int D.20740;
  int D.20741;
  unsigned int D.20742;
  unsigned int D.20743;

  D.20739 = ctx->image;
  D.20740 = D.20739->tables[table].size_bitfield;
  D.20741 = column * 2;
  D.20742 = D.20740 >> D.20741;
  D.20743 = D.20742 & 3;
  D.20738 = D.20743 + 1;
  return D.20738;
}


verify_field_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.20745;
  <unnamed-unsigned:24> D.20746;
  int D.20747;
  unsigned int D.20750;
  int D.20753;
  gchar * D.20756;
  struct GSList * D.20757;
  struct GSList * D.20758;
  unsigned int D.20759;
  gchar * D.20764;
  struct GSList * D.20765;
  unsigned int D.20766;
  gchar * D.20771;
  struct GSList * D.20772;
  unsigned int D.20773;
  gchar * D.20778;
  struct GSList * D.20779;
  unsigned int D.20780;
  gchar * D.20785;
  struct GSList * D.20786;
  unsigned int D.20787;
  unsigned int i.32;
  unsigned int D.20791;
  int D.20792;
  gchar * D.20797;
  struct GSList * D.20798;
  unsigned int D.20799;
  unsigned int D.20802;
  int D.20803;
  gchar * D.20808;
  struct GSList * D.20809;
  unsigned int D.20810;
  unsigned int D.20813;
  int D.20814;
  gchar * D.20819;
  struct GSList * D.20820;
  unsigned int D.20821;
  int D.20824;
  unsigned int D.20825;
  int D.20826;
  gchar * D.20831;
  struct GSList * D.20832;
  unsigned int D.20835;
  int D.20837;
  gchar * D.20840;
  struct GSList * D.20841;
  unsigned int D.20842;
  int D.20845;
  gchar * D.20850;
  struct GSList * D.20851;
  unsigned int D.20854;
  gchar * D.20859;
  struct GSList * D.20860;
  _Bool D.20861;
  _Bool D.20862;
  _Bool D.20863;
  gchar * D.20868;
  struct GSList * D.20869;
  <unnamed-unsigned:24> D.20870;
  int D.20871;
  struct MonoTableInfo * table;
  guint32 data[3];
  guint32 flags;
  guint32 module_field_list;
  int i;

  try
    {
      D.20745 = ctx->image;
      table = &D.20745->tables[4];
      module_field_list = 4294967295;
      D.20745 = ctx->image;
      D.20746 = D.20745->tables[2].rows;
      D.20747 = (int) D.20746;
      if (D.20747 > 1) goto <D.20748>; else goto <D.20749>;
      <D.20748>:
      {
        struct MonoTableInfo * type;

        D.20745 = ctx->image;
        type = &D.20745->tables[2];
        module_field_list = mono_metadata_decode_row_col (type, 1, 4);
      }
      <D.20749>:
      i = 0;
      goto <D.18449>;
      <D.18448>:
      mono_metadata_decode_row (table, i, &data, 3);
      flags = data[0];
      D.20750 = flags & 18440;
      if (D.20750 != 0) goto <D.20751>; else goto <D.20752>;
      <D.20751>:
      D.20753 = ctx->report_error;
      if (D.20753 != 0) goto <D.20754>; else goto <D.20755>;
      <D.20754>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20756 = monoeg_g_strdup_printf ("Invalid field row %d invalid flags field 0x%08x", i, flags);
        vinfo->info.message = D.20756;
        vinfo->exception_type = 3;
        D.20757 = ctx->errors;
        D.20758 = monoeg_g_slist_prepend (D.20757, vinfo);
        ctx->errors = D.20758;
      }
      <D.20755>:
      ctx->valid = 0;
      return;
      <D.20752>:
      D.20759 = flags & 7;
      if (D.20759 == 7) goto <D.20760>; else goto <D.20761>;
      <D.20760>:
      D.20753 = ctx->report_error;
      if (D.20753 != 0) goto <D.20762>; else goto <D.20763>;
      <D.20762>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20764 = monoeg_g_strdup_printf ("Invalid field row %d invalid field visibility 0x7", i);
        vinfo->info.message = D.20764;
        vinfo->exception_type = 3;
        D.20757 = ctx->errors;
        D.20765 = monoeg_g_slist_prepend (D.20757, vinfo);
        ctx->errors = D.20765;
      }
      <D.20763>:
      ctx->valid = 0;
      return;
      <D.20761>:
      D.20766 = flags & 96;
      if (D.20766 == 96) goto <D.20767>; else goto <D.20768>;
      <D.20767>:
      D.20753 = ctx->report_error;
      if (D.20753 != 0) goto <D.20769>; else goto <D.20770>;
      <D.20769>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20771 = monoeg_g_strdup_printf ("Invalid field row %d cannot be InitOnly and Literal at the same time", i);
        vinfo->info.message = D.20771;
        vinfo->exception_type = 3;
        D.20757 = ctx->errors;
        D.20772 = monoeg_g_slist_prepend (D.20757, vinfo);
        ctx->errors = D.20772;
      }
      <D.20770>:
      ctx->valid = 0;
      return;
      <D.20768>:
      D.20773 = flags & 1536;
      if (D.20773 == 1024) goto <D.20774>; else goto <D.20775>;
      <D.20774>:
      D.20753 = ctx->report_error;
      if (D.20753 != 0) goto <D.20776>; else goto <D.20777>;
      <D.20776>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20778 = monoeg_g_strdup_printf ("Invalid field row %d is RTSpecialName but not SpecialName", i);
        vinfo->info.message = D.20778;
        vinfo->exception_type = 3;
        D.20757 = ctx->errors;
        D.20779 = monoeg_g_slist_prepend (D.20757, vinfo);
        ctx->errors = D.20779;
      }
      <D.20777>:
      ctx->valid = 0;
      return;
      <D.20775>:
      D.20780 = flags & 80;
      if (D.20780 == 64) goto <D.20781>; else goto <D.20782>;
      <D.20781>:
      D.20753 = ctx->report_error;
      if (D.20753 != 0) goto <D.20783>; else goto <D.20784>;
      <D.20783>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20785 = monoeg_g_strdup_printf ("Invalid field row %d is Literal but not Static", i);
        vinfo->info.message = D.20785;
        vinfo->exception_type = 3;
        D.20757 = ctx->errors;
        D.20786 = monoeg_g_slist_prepend (D.20757, vinfo);
        ctx->errors = D.20786;
      }
      <D.20784>:
      ctx->valid = 0;
      return;
      <D.20782>:
      D.20787 = flags & 4096;
      if (D.20787 != 0) goto <D.20788>; else goto <D.20789>;
      <D.20788>:
      i.32 = (unsigned int) i;
      D.20791 = make_coded_token (32, 4, i.32);
      D.20792 = search_sorted_table (ctx, 13, 0, D.20791);
      if (D.20792 == -1) goto <D.20793>; else goto <D.20794>;
      <D.20793>:
      D.20753 = ctx->report_error;
      if (D.20753 != 0) goto <D.20795>; else goto <D.20796>;
      <D.20795>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20797 = 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.20797;
        vinfo->exception_type = 3;
        D.20757 = ctx->errors;
        D.20798 = monoeg_g_slist_prepend (D.20757, vinfo);
        ctx->errors = D.20798;
      }
      <D.20796>:
      ctx->valid = 0;
      return;
      <D.20794>:
      <D.20789>:
      D.20799 = flags & 32768;
      if (D.20799 != 0) goto <D.20800>; else goto <D.20801>;
      <D.20800>:
      i.32 = (unsigned int) i;
      D.20802 = make_coded_token (5, 4, i.32);
      D.20803 = search_sorted_table (ctx, 11, 2, D.20802);
      if (D.20803 == -1) goto <D.20804>; else goto <D.20805>;
      <D.20804>:
      D.20753 = ctx->report_error;
      if (D.20753 != 0) goto <D.20806>; else goto <D.20807>;
      <D.20806>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20808 = 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.20808;
        vinfo->exception_type = 3;
        D.20757 = ctx->errors;
        D.20809 = monoeg_g_slist_prepend (D.20757, vinfo);
        ctx->errors = D.20809;
      }
      <D.20807>:
      ctx->valid = 0;
      return;
      <D.20805>:
      <D.20801>:
      D.20810 = flags & 64;
      if (D.20810 != 0) goto <D.20811>; else goto <D.20812>;
      <D.20811>:
      i.32 = (unsigned int) i;
      D.20813 = make_coded_token (5, 4, i.32);
      D.20814 = search_sorted_table (ctx, 11, 2, D.20813);
      if (D.20814 == -1) goto <D.20815>; else goto <D.20816>;
      <D.20815>:
      D.20753 = ctx->report_error;
      if (D.20753 != 0) goto <D.20817>; else goto <D.20818>;
      <D.20817>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20819 = 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.20819;
        vinfo->exception_type = 3;
        D.20757 = ctx->errors;
        D.20820 = monoeg_g_slist_prepend (D.20757, vinfo);
        ctx->errors = D.20820;
      }
      <D.20818>:
      ctx->valid = 0;
      return;
      <D.20816>:
      <D.20812>:
      D.20821 = flags & 256;
      if (D.20821 != 0) goto <D.20822>; else goto <D.20823>;
      <D.20822>:
      D.20824 = i + 1;
      D.20825 = (unsigned int) D.20824;
      D.20826 = search_sorted_table (ctx, 29, 1, D.20825);
      if (D.20826 == -1) goto <D.20827>; else goto <D.20828>;
      <D.20827>:
      D.20753 = ctx->report_error;
      if (D.20753 != 0) goto <D.20829>; else goto <D.20830>;
      <D.20829>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20831 = 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.20831;
        vinfo->exception_type = 3;
        D.20757 = ctx->errors;
        D.20832 = monoeg_g_slist_prepend (D.20757, vinfo);
        ctx->errors = D.20832;
      }
      <D.20830>:
      ctx->valid = 0;
      return;
      <D.20828>:
      <D.20823>:
      D.20835 = data[1];
      if (D.20835 == 0) goto <D.20833>; else goto <D.20836>;
      <D.20836>:
      D.20835 = data[1];
      D.20837 = is_valid_non_empty_string (ctx, D.20835);
      if (D.20837 == 0) goto <D.20833>; else goto <D.20834>;
      <D.20833>:
      D.20753 = ctx->report_error;
      if (D.20753 != 0) goto <D.20838>; else goto <D.20839>;
      <D.20838>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20835 = data[1];
        D.20840 = monoeg_g_strdup_printf ("Invalid field row %d invalid name token %08x", i, D.20835);
        vinfo->info.message = D.20840;
        vinfo->exception_type = 3;
        D.20757 = ctx->errors;
        D.20841 = monoeg_g_slist_prepend (D.20757, vinfo);
        ctx->errors = D.20841;
      }
      <D.20839>:
      ctx->valid = 0;
      return;
      <D.20834>:
      D.20842 = data[2];
      if (D.20842 != 0) goto <D.20843>; else goto <D.20844>;
      <D.20843>:
      D.20842 = data[2];
      D.20845 = is_valid_blob_object (ctx, D.20842, 1);
      if (D.20845 == 0) goto <D.20846>; else goto <D.20847>;
      <D.20846>:
      D.20753 = ctx->report_error;
      if (D.20753 != 0) goto <D.20848>; else goto <D.20849>;
      <D.20848>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20842 = data[2];
        D.20850 = monoeg_g_strdup_printf ("Invalid field row %d invalid signature blob token 0x%x", i, D.20842);
        vinfo->info.message = D.20850;
        vinfo->exception_type = 3;
        D.20757 = ctx->errors;
        D.20851 = monoeg_g_slist_prepend (D.20757, vinfo);
        ctx->errors = D.20851;
      }
      <D.20849>:
      ctx->valid = 0;
      return;
      <D.20847>:
      <D.20844>:
      D.20824 = i + 1;
      D.20825 = (unsigned int) D.20824;
      if (D.20825 < module_field_list) goto <D.20852>; else goto <D.20853>;
      <D.20852>:
      {
        guint32 access;

        access = flags & 7;
        D.20854 = flags & 16;
        if (D.20854 == 0) goto <D.20855>; else goto <D.20856>;
        <D.20855>:
        D.20753 = ctx->report_error;
        if (D.20753 != 0) goto <D.20857>; else goto <D.20858>;
        <D.20857>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.20859 = monoeg_g_strdup_printf ("Invalid field row %d is a global variable but is not static", i);
          vinfo->info.message = D.20859;
          vinfo->exception_type = 3;
          D.20757 = ctx->errors;
          D.20860 = monoeg_g_slist_prepend (D.20757, vinfo);
          ctx->errors = D.20860;
        }
        <D.20858>:
        ctx->valid = 0;
        return;
        <D.20856>:
        D.20861 = access > 1;
        D.20862 = access != 6;
        D.20863 = D.20861 & D.20862;
        if (D.20863 != 0) goto <D.20864>; else goto <D.20865>;
        <D.20864>:
        D.20753 = ctx->report_error;
        if (D.20753 != 0) goto <D.20866>; else goto <D.20867>;
        <D.20866>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.20868 = monoeg_g_strdup_printf ("Invalid field row %d is a global variable but have wrong visibility %x", i, access);
          vinfo->info.message = D.20868;
          vinfo->exception_type = 3;
          D.20757 = ctx->errors;
          D.20869 = monoeg_g_slist_prepend (D.20757, vinfo);
          ctx->errors = D.20869;
        }
        <D.20867>:
        ctx->valid = 0;
        return;
        <D.20865>:
      }
      <D.20853>:
      i = i + 1;
      <D.18449>:
      D.20870 = table->rows;
      D.20871 = (int) D.20870;
      if (D.20871 > i) goto <D.18448>; else goto <D.18450>;
      <D.18450>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


make_coded_token (int kind, guint32 table, guint32 table_idx)
{
  int kind.33;
  unsigned char D.20876;
  int kind.34;
  unsigned char D.20878;
  int kind.35;
  unsigned char D.20880;
  unsigned int D.20881;
  guint32 D.20884;
  unsigned int D.20885;
  int bits.36;
  unsigned int D.20887;
  guint32 bits;
  guint32 tables;
  guint32 i;

  kind.33 = kind;
  kind = kind.33 + 1;
  D.20876 = coded_index_desc[kind.33];
  bits = (guint32) D.20876;
  kind.34 = kind;
  kind = kind.34 + 1;
  D.20878 = coded_index_desc[kind.34];
  tables = (guint32) D.20878;
  i = 0;
  goto <D.17723>;
  <D.17722>:
  kind.35 = kind;
  kind = kind.35 + 1;
  D.20880 = coded_index_desc[kind.35];
  D.20881 = (unsigned int) D.20880;
  if (D.20881 == table) goto <D.20882>; else goto <D.20883>;
  <D.20882>:
  D.20885 = table_idx + 1;
  bits.36 = (int) bits;
  D.20887 = D.20885 << bits.36;
  D.20884 = D.20887 | i;
  return D.20884;
  <D.20883>:
  i = i + 1;
  <D.17723>:
  if (i < tables) goto <D.17722>; else goto <D.17724>;
  <D.17724>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata-verify.c", 1012);
  D.20884 = 4294967295;
  return D.20884;
}


is_valid_blob_object (struct VerifyContext * ctx, guint32 offset, guint32 minsize)
{
  struct MonoImage * D.20889;
  struct MonoStreamHeader * D.20890;
  unsigned int D.20891;
  gboolean D.20894;
  unsigned int D.20895;
  unsigned int D.20896;
  const char * D.20897;
  sizetype D.20898;
  const char * D.20899;
  int D.20900;
  unsigned int entry_size.37;
  unsigned int bytes.38;
  unsigned int D.20907;
  unsigned int entry_size.39;
  int iftmp.40;
  unsigned int D.20914;
  unsigned int D.20916;
  struct OffsetAndSize blob;
  guint32 entry_size;
  guint32 bytes;

  try
    {
      D.20889 = ctx->image;
      D.20890 = &D.20889->heap_blob;
      blob = get_metadata_stream (ctx, D.20890); [return slot optimization]
      D.20891 = blob.size;
      if (D.20891 < offset) goto <D.20892>; else goto <D.20893>;
      <D.20892>:
      D.20894 = 0;
      return D.20894;
      <D.20893>:
      D.20891 = blob.size;
      D.20895 = blob.offset;
      D.20896 = D.20891 - D.20895;
      D.20897 = ctx->data;
      D.20895 = blob.offset;
      D.20898 = D.20895 + offset;
      D.20899 = D.20897 + D.20898;
      D.20900 = decode_value (D.20899, D.20896, &entry_size, &bytes);
      if (D.20900 == 0) goto <D.20901>; else goto <D.20902>;
      <D.20901>:
      D.20894 = 0;
      return D.20894;
      <D.20902>:
      entry_size.37 = entry_size;
      if (entry_size.37 < minsize) goto <D.20904>; else goto <D.20905>;
      <D.20904>:
      D.20894 = 0;
      return D.20894;
      <D.20905>:
      bytes.38 = bytes;
      D.20907 = ~bytes.38;
      entry_size.37 = entry_size;
      if (D.20907 < entry_size.37) goto <D.20908>; else goto <D.20909>;
      <D.20908>:
      D.20894 = 0;
      return D.20894;
      <D.20909>:
      entry_size.37 = entry_size;
      bytes.38 = bytes;
      entry_size.39 = entry_size.37 + bytes.38;
      entry_size = entry_size.39;
      entry_size.37 = entry_size;
      D.20914 = offset + entry_size.37;
      D.20891 = blob.size;
      if (D.20914 <= D.20891) goto <D.20915>; else goto <D.20912>;
      <D.20915>:
      entry_size.37 = entry_size;
      D.20916 = ~entry_size.37;
      if (D.20916 >= offset) goto <D.20917>; else goto <D.20912>;
      <D.20917>:
      iftmp.40 = 1;
      goto <D.20913>;
      <D.20912>:
      iftmp.40 = 0;
      <D.20913>:
      D.20894 = iftmp.40;
      return D.20894;
    }
  finally
    {
      blob = {CLOBBER};
      entry_size = {CLOBBER};
      bytes = {CLOBBER};
    }
}


decode_value (const char * _ptr, unsigned int available, unsigned int * value, unsigned int * size)
{
  gboolean D.20922;
  unsigned int D.20923;
  signed char b.41;
  unsigned int D.20927;
  int D.20929;
  int D.20930;
  int D.20935;
  int D.20936;
  const unsigned char * D.20937;
  unsigned char D.20938;
  int D.20939;
  int D.20940;
  unsigned int D.20941;
  int D.20945;
  int D.20946;
  int D.20947;
  int D.20948;
  const unsigned char * D.20949;
  unsigned char D.20950;
  int D.20951;
  int D.20952;
  int D.20953;
  const unsigned char * D.20954;
  unsigned char D.20955;
  int D.20956;
  int D.20957;
  unsigned int D.20958;
  unsigned char b;
  const unsigned char * ptr;

  ptr = _ptr;
  if (available == 0) goto <D.20920>; else goto <D.20921>;
  <D.20920>:
  D.20922 = 0;
  return D.20922;
  <D.20921>:
  b = *ptr;
  *size = 0;
  D.20923 = *size;
  *value = D.20923;
  b.41 = (signed char) b;
  if (b.41 >= 0) goto <D.20925>; else goto <D.20926>;
  <D.20925>:
  *size = 1;
  D.20927 = (unsigned int) b;
  *value = D.20927;
  goto <D.20928>;
  <D.20926>:
  D.20929 = (int) b;
  D.20930 = D.20929 & 64;
  if (D.20930 == 0) goto <D.20931>; else goto <D.20932>;
  <D.20931>:
  if (available <= 1) goto <D.20933>; else goto <D.20934>;
  <D.20933>:
  D.20922 = 0;
  return D.20922;
  <D.20934>:
  *size = 2;
  D.20929 = (int) b;
  D.20935 = D.20929 & 63;
  D.20936 = D.20935 << 8;
  D.20937 = ptr + 1;
  D.20938 = *D.20937;
  D.20939 = (int) D.20938;
  D.20940 = D.20936 | D.20939;
  D.20941 = (unsigned int) D.20940;
  *value = D.20941;
  goto <D.20942>;
  <D.20932>:
  if (available <= 3) goto <D.20943>; else goto <D.20944>;
  <D.20943>:
  D.20922 = 0;
  return D.20922;
  <D.20944>:
  *size = 4;
  D.20929 = (int) b;
  D.20945 = D.20929 & 31;
  D.20946 = D.20945 << 24;
  D.20937 = ptr + 1;
  D.20938 = *D.20937;
  D.20939 = (int) D.20938;
  D.20947 = D.20939 << 16;
  D.20948 = D.20946 | D.20947;
  D.20949 = ptr + 2;
  D.20950 = *D.20949;
  D.20951 = (int) D.20950;
  D.20952 = D.20951 << 8;
  D.20953 = D.20948 | D.20952;
  D.20954 = ptr + 3;
  D.20955 = *D.20954;
  D.20956 = (int) D.20955;
  D.20957 = D.20953 | D.20956;
  D.20958 = (unsigned int) D.20957;
  *value = D.20958;
  <D.20942>:
  <D.20928>:
  D.20922 = 1;
  return D.20922;
}


verify_method_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.20960;
  <unnamed-unsigned:24> D.20961;
  int D.20962;
  unsigned int D.20965;
  int D.20968;
  gchar * D.20971;
  struct GSList * D.20972;
  struct GSList * D.20973;
  gchar * D.20978;
  struct GSList * D.20979;
  unsigned int D.20982;
  int D.20984;
  gchar * D.20987;
  struct GSList * D.20988;
  int D.18489;
  int iftmp.42;
  int D.18485;
  const char[6] * D.20992;
  unsigned char D.20993;
  int D.20994;
  unsigned char D.20995;
  int D.20996;
  _Bool D.20997;
  _Bool D.20998;
  _Bool D.20999;
  const unsigned char * D.21002;
  unsigned char D.21003;
  int D.21004;
  const unsigned char * D.21005;
  unsigned char D.21006;
  int D.21007;
  _Bool D.21008;
  _Bool D.21009;
  const unsigned char * D.21012;
  unsigned char D.21013;
  int D.21014;
  const unsigned char * D.21015;
  unsigned char D.21016;
  int D.21017;
  _Bool D.21018;
  _Bool D.21019;
  const unsigned char * D.21022;
  unsigned char D.21023;
  int D.21024;
  const unsigned char * D.21025;
  unsigned char D.21026;
  int D.21027;
  _Bool D.21029;
  int D.18498;
  int iftmp.43;
  int D.18494;
  const char[7] * D.21033;
  unsigned char D.21034;
  int D.21035;
  unsigned char D.21036;
  int D.21037;
  _Bool D.21038;
  _Bool D.21039;
  _Bool D.21040;
  const unsigned char * D.21043;
  unsigned char D.21044;
  int D.21045;
  const unsigned char * D.21046;
  unsigned char D.21047;
  int D.21048;
  _Bool D.21049;
  _Bool D.21050;
  const unsigned char * D.21053;
  unsigned char D.21054;
  int D.21055;
  const unsigned char * D.21056;
  unsigned char D.21057;
  int D.21058;
  _Bool D.21059;
  _Bool D.21060;
  const unsigned char * D.21063;
  unsigned char D.21064;
  int D.21065;
  const unsigned char * D.21066;
  unsigned char D.21067;
  int D.21068;
  _Bool D.21070;
  int D.21071;
  unsigned int i.44;
  unsigned int D.21075;
  int D.21076;
  gchar * D.21081;
  struct GSList * D.21082;
  unsigned int D.21083;
  unsigned int D.21086;
  gchar * D.21091;
  struct GSList * D.21092;
  unsigned int D.21093;
  unsigned int D.21096;
  gchar * D.21101;
  struct GSList * D.21102;
  unsigned int D.21103;
  gchar * D.21108;
  struct GSList * D.21109;
  unsigned int D.21110;
  gchar * D.21115;
  struct GSList * D.21116;
  unsigned int D.21119;
  int D.21122;
  gchar * D.21125;
  struct GSList * D.21126;
  unsigned int D.21127;
  gchar * D.21132;
  struct GSList * D.21133;
  int D.21134;
  unsigned int D.21135;
  gchar * D.21142;
  struct GSList * D.21143;
  unsigned int D.21144;
  gchar * D.21149;
  struct GSList * D.21150;
  _Bool D.21153;
  _Bool D.21154;
  _Bool D.21155;
  gchar * D.21159;
  struct GSList * D.21160;
  unsigned int D.21161;
  gchar * D.21168;
  struct GSList * D.21169;
  gchar * D.21176;
  struct GSList * D.21177;
  gchar * D.21182;
  struct GSList * D.21183;
  unsigned int D.21184;
  unsigned int D.21189;
  gchar * D.21196;
  struct GSList * D.21197;
  unsigned int D.21198;
  gchar * D.21205;
  struct GSList * D.21206;
  unsigned int D.21211;
  gchar * D.21215;
  struct GSList * D.21216;
  gchar * D.21221;
  struct GSList * D.21222;
  gchar * D.21232;
  struct GSList * D.21233;
  gchar * D.21240;
  struct GSList * D.21241;
  unsigned int D.21242;
  int D.21243;
  gchar * D.21248;
  struct GSList * D.21249;
  unsigned int D.21250;
  gchar * D.21257;
  struct GSList * D.21258;
  gchar * D.21265;
  struct GSList * D.21266;
  unsigned int D.21267;
  int D.21270;
  gchar * D.21275;
  struct GSList * D.21276;
  unsigned int D.21277;
  gchar * D.21282;
  struct GSList * D.21283;
  gchar * D.21288;
  struct GSList * D.21289;
  <unnamed-unsigned:24> D.21290;
  int D.21291;
  int D.21292;
  unsigned int D.21293;
  gchar * D.21298;
  struct GSList * D.21299;
  <unnamed-unsigned:24> D.21300;
  int D.21301;
  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.20960 = ctx->image;
      table = &D.20960->tables[6];
      paramlist = 1;
      module_method_list = 4294967295;
      D.20960 = ctx->image;
      D.20961 = D.20960->tables[2].rows;
      D.20962 = (int) D.20961;
      if (D.20962 > 1) goto <D.20963>; else goto <D.20964>;
      <D.20963>:
      {
        struct MonoTableInfo * type;

        D.20960 = ctx->image;
        type = &D.20960->tables[2];
        module_method_list = mono_metadata_decode_row_col (type, 1, 5);
      }
      <D.20964>:
      i = 0;
      goto <D.18526>;
      <D.18525>:
      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.20965 = implflags & 60928;
      if (D.20965 != 0) goto <D.20966>; else goto <D.20967>;
      <D.20966>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.20969>; else goto <D.20970>;
      <D.20969>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20971 = monoeg_g_strdup_printf ("Invalid method row %d invalid implflags field 0x%08x", i, implflags);
        vinfo->info.message = D.20971;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.20973 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.20973;
      }
      <D.20970>:
      ctx->valid = 0;
      return;
      <D.20967>:
      if (access == 7) goto <D.20974>; else goto <D.20975>;
      <D.20974>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.20976>; else goto <D.20977>;
      <D.20976>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20978 = monoeg_g_strdup_printf ("Invalid method row %d invalid MemberAccessMask 0x7", i);
        vinfo->info.message = D.20978;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.20979 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.20979;
      }
      <D.20977>:
      ctx->valid = 0;
      return;
      <D.20975>:
      D.20982 = data[3];
      if (D.20982 == 0) goto <D.20980>; else goto <D.20983>;
      <D.20983>:
      D.20982 = data[3];
      D.20984 = is_valid_non_empty_string (ctx, D.20982);
      if (D.20984 == 0) goto <D.20980>; else goto <D.20981>;
      <D.20980>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.20985>; else goto <D.20986>;
      <D.20985>:
      {
        struct MonoVerifyInfoExtended * vinfo;

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

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

          __s2 = name;
          D.20992 = ".ctor";
          D.20993 = MEM[(const unsigned char *)D.20992];
          D.20994 = (int) D.20993;
          D.20995 = *__s2;
          D.20996 = (int) D.20995;
          __result = D.20994 - D.20996;
          {
            D.20997 = __s1_len != 0;
            D.20998 = __result == 0;
            D.20999 = D.20997 & D.20998;
            if (D.20999 != 0) goto <D.21000>; else goto <D.21001>;
            <D.21000>:
            D.21002 = &MEM[(void *)".ctor" + 1B];
            D.21003 = *D.21002;
            D.21004 = (int) D.21003;
            D.21005 = __s2 + 1;
            D.21006 = *D.21005;
            D.21007 = (int) D.21006;
            __result = D.21004 - D.21007;
            D.21008 = __s1_len > 1;
            D.20998 = __result == 0;
            D.21009 = D.21008 & D.20998;
            if (D.21009 != 0) goto <D.21010>; else goto <D.21011>;
            <D.21010>:
            D.21012 = &MEM[(void *)".ctor" + 2B];
            D.21013 = *D.21012;
            D.21014 = (int) D.21013;
            D.21015 = __s2 + 2;
            D.21016 = *D.21015;
            D.21017 = (int) D.21016;
            __result = D.21014 - D.21017;
            D.21018 = __s1_len > 2;
            D.20998 = __result == 0;
            D.21019 = D.21018 & D.20998;
            if (D.21019 != 0) goto <D.21020>; else goto <D.21021>;
            <D.21020>:
            D.21022 = &MEM[(void *)".ctor" + 3B];
            D.21023 = *D.21022;
            D.21024 = (int) D.21023;
            D.21025 = __s2 + 3;
            D.21026 = *D.21025;
            D.21027 = (int) D.21026;
            __result = D.21024 - D.21027;
            <D.21021>:
            <D.21011>:
            <D.21001>:
          }
          D.18485 = __result;
        }
        iftmp.42 = D.18485;
        goto <D.21028>;
        <D.20991>:
        iftmp.42 = __builtin_strcmp (".ctor", name);
        <D.21028>:
        D.18489 = iftmp.42;
      }
      D.21029 = D.18489 == 0;
      is_ctor = (gboolean) D.21029;
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = name;
          D.21033 = ".cctor";
          D.21034 = MEM[(const unsigned char *)D.21033];
          D.21035 = (int) D.21034;
          D.21036 = *__s2;
          D.21037 = (int) D.21036;
          __result = D.21035 - D.21037;
          {
            D.21038 = __s1_len != 0;
            D.21039 = __result == 0;
            D.21040 = D.21038 & D.21039;
            if (D.21040 != 0) goto <D.21041>; else goto <D.21042>;
            <D.21041>:
            D.21043 = &MEM[(void *)".cctor" + 1B];
            D.21044 = *D.21043;
            D.21045 = (int) D.21044;
            D.21046 = __s2 + 1;
            D.21047 = *D.21046;
            D.21048 = (int) D.21047;
            __result = D.21045 - D.21048;
            D.21049 = __s1_len > 1;
            D.21039 = __result == 0;
            D.21050 = D.21049 & D.21039;
            if (D.21050 != 0) goto <D.21051>; else goto <D.21052>;
            <D.21051>:
            D.21053 = &MEM[(void *)".cctor" + 2B];
            D.21054 = *D.21053;
            D.21055 = (int) D.21054;
            D.21056 = __s2 + 2;
            D.21057 = *D.21056;
            D.21058 = (int) D.21057;
            __result = D.21055 - D.21058;
            D.21059 = __s1_len > 2;
            D.21039 = __result == 0;
            D.21060 = D.21059 & D.21039;
            if (D.21060 != 0) goto <D.21061>; else goto <D.21062>;
            <D.21061>:
            D.21063 = &MEM[(void *)".cctor" + 3B];
            D.21064 = *D.21063;
            D.21065 = (int) D.21064;
            D.21066 = __s2 + 3;
            D.21067 = *D.21066;
            D.21068 = (int) D.21067;
            __result = D.21065 - D.21068;
            <D.21062>:
            <D.21052>:
            <D.21042>:
          }
          D.18494 = __result;
        }
        iftmp.43 = D.18494;
        goto <D.21069>;
        <D.21032>:
        iftmp.43 = __builtin_strcmp (".cctor", name);
        <D.21069>:
        D.18498 = iftmp.43;
      }
      D.21070 = D.18498 == 0;
      is_cctor = (gboolean) D.21070;
      D.21071 = is_ctor | is_cctor;
      if (D.21071 != 0) goto <D.21072>; else goto <D.21073>;
      <D.21072>:
      i.44 = (unsigned int) i;
      D.21075 = make_coded_token (78, 6, i.44);
      D.21076 = search_sorted_table (ctx, 42, 2, D.21075);
      if (D.21076 != -1) goto <D.21077>; else goto <D.21078>;
      <D.21077>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21079>; else goto <D.21080>;
      <D.21079>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21081 = monoeg_g_strdup_printf ("Invalid method row %d .ctor or .cctor has generic param", i);
        vinfo->info.message = D.21081;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21082 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21082;
      }
      <D.21080>:
      ctx->valid = 0;
      return;
      <D.21078>:
      <D.21073>:
      D.21083 = flags & 16;
      if (D.21083 != 0) goto <D.21084>; else goto <D.21085>;
      <D.21084>:
      D.21086 = flags & 352;
      if (D.21086 != 0) goto <D.21087>; else goto <D.21088>;
      <D.21087>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21089>; else goto <D.21090>;
      <D.21089>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21091 = monoeg_g_strdup_printf ("Invalid method row %d is static and (final, virtual or new slot)", i);
        vinfo->info.message = D.21091;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21092 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21092;
      }
      <D.21090>:
      ctx->valid = 0;
      return;
      <D.21088>:
      <D.21085>:
      D.21093 = flags & 1024;
      if (D.21093 != 0) goto <D.21094>; else goto <D.21095>;
      <D.21094>:
      D.21096 = flags & 8192;
      if (D.21096 != 0) goto <D.21097>; else goto <D.21098>;
      <D.21097>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21099>; else goto <D.21100>;
      <D.21099>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21101 = monoeg_g_strdup_printf ("Invalid method row %d is Abstract and PinvokeImpl", i);
        vinfo->info.message = D.21101;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21102 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21102;
      }
      <D.21100>:
      ctx->valid = 0;
      return;
      <D.21098>:
      D.21103 = flags & 32;
      if (D.21103 != 0) goto <D.21104>; else goto <D.21105>;
      <D.21104>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21106>; else goto <D.21107>;
      <D.21106>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21108 = monoeg_g_strdup_printf ("Invalid method row %d is Abstract and Final", i);
        vinfo->info.message = D.21108;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21109 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21109;
      }
      <D.21107>:
      ctx->valid = 0;
      return;
      <D.21105>:
      D.21110 = flags & 64;
      if (D.21110 == 0) goto <D.21111>; else goto <D.21112>;
      <D.21111>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21113>; else goto <D.21114>;
      <D.21113>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21115 = monoeg_g_strdup_printf ("Invalid method row %d is Abstract but not Virtual", i);
        vinfo->info.message = D.21115;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21116 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21116;
      }
      <D.21114>:
      ctx->valid = 0;
      return;
      <D.21112>:
      <D.21095>:
      if (access == 0) goto <D.21117>; else goto <D.21118>;
      <D.21117>:
      D.21119 = flags & 6144;
      if (D.21119 != 0) goto <D.21120>; else goto <D.21121>;
      <D.21120>:
      D.21122 = ctx->report_warning;
      if (D.21122 != 0) goto <D.21123>; else goto <D.21124>;
      <D.21123>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 2;
        D.21125 = monoeg_g_strdup_printf ("Invalid method row %d is CompileControlled and SpecialName or RtSpecialName", i);
        vinfo->info.message = D.21125;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21126 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21126;
      }
      ctx->valid = 0;
      return;
      <D.21124>:
      <D.21121>:
      <D.21118>:
      D.21127 = flags & 6144;
      if (D.21127 == 4096) goto <D.21128>; else goto <D.21129>;
      <D.21128>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21130>; else goto <D.21131>;
      <D.21130>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21132 = monoeg_g_strdup_printf ("Invalid method row %d is RTSpecialName but not SpecialName", i);
        vinfo->info.message = D.21132;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21133 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21133;
      }
      <D.21131>:
      ctx->valid = 0;
      return;
      <D.21129>:
      D.21134 = i + 1;
      D.21135 = (unsigned int) D.21134;
      if (D.21135 < module_method_list) goto <D.21136>; else goto <D.21137>;
      <D.21136>:
      D.21083 = flags & 16;
      if (D.21083 == 0) goto <D.21138>; else goto <D.21139>;
      <D.21138>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21140>; else goto <D.21141>;
      <D.21140>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21142 = monoeg_g_strdup_printf ("Invalid method row %d is a global method but not Static", i);
        vinfo->info.message = D.21142;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21143 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21143;
      }
      <D.21141>:
      ctx->valid = 0;
      return;
      <D.21139>:
      D.21144 = flags & 1088;
      if (D.21144 != 0) goto <D.21145>; else goto <D.21146>;
      <D.21145>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21147>; else goto <D.21148>;
      <D.21147>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21149 = monoeg_g_strdup_printf ("Invalid method row %d is a global method but is Abstract or Virtual", i);
        vinfo->info.message = D.21149;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21150 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21150;
      }
      <D.21148>:
      ctx->valid = 0;
      return;
      <D.21146>:
      D.21153 = access == 4;
      D.21154 = access == 2;
      D.21155 = D.21153 | D.21154;
      if (D.21155 != 0) goto <D.21151>; else goto <D.21156>;
      <D.21156>:
      if (access == 5) goto <D.21151>; else goto <D.21152>;
      <D.21151>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21157>; else goto <D.21158>;
      <D.21157>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21159 = monoeg_g_strdup_printf ("Invalid method row %d is a global method but not CompilerControled, Public, Private or Assembly", i);
        vinfo->info.message = D.21159;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21160 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21160;
      }
      <D.21158>:
      ctx->valid = 0;
      return;
      <D.21152>:
      <D.21137>:
      D.21161 = flags & 800;
      if (D.21161 != 0) goto <D.21162>; else goto <D.21163>;
      <D.21162>:
      D.21110 = flags & 64;
      if (D.21110 == 0) goto <D.21164>; else goto <D.21165>;
      <D.21164>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21166>; else goto <D.21167>;
      <D.21166>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21168 = monoeg_g_strdup_printf ("Invalid method row %d is (Final, NewSlot or Strict) but not Virtual", i);
        vinfo->info.message = D.21168;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21169 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21169;
      }
      <D.21167>:
      ctx->valid = 0;
      return;
      <D.21165>:
      <D.21163>:
      D.21096 = flags & 8192;
      if (D.21096 != 0) goto <D.21170>; else goto <D.21171>;
      <D.21170>:
      D.21110 = flags & 64;
      if (D.21110 != 0) goto <D.21172>; else goto <D.21173>;
      <D.21172>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21174>; else goto <D.21175>;
      <D.21174>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21176 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl and Virtual", i);
        vinfo->info.message = D.21176;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21177 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21177;
      }
      <D.21175>:
      ctx->valid = 0;
      return;
      <D.21173>:
      D.21083 = flags & 16;
      if (D.21083 == 0) goto <D.21178>; else goto <D.21179>;
      <D.21178>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21180>; else goto <D.21181>;
      <D.21180>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21182 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl but not Static", i);
        vinfo->info.message = D.21182;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21183 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21183;
      }
      <D.21181>:
      ctx->valid = 0;
      return;
      <D.21179>:
      <D.21171>:
      D.21093 = flags & 1024;
      D.21184 = D.21093 | rva;
      if (D.21184 == 0) goto <D.21185>; else goto <D.21186>;
      <D.21185>:
      D.21096 = flags & 8192;
      if (D.21096 == 0) goto <D.21187>; else goto <D.21188>;
      <D.21187>:
      D.21189 = implflags & 4096;
      if (D.21189 == 0) goto <D.21190>; else goto <D.21191>;
      <D.21190>:
      if (code_type != 3) goto <D.21192>; else goto <D.21193>;
      <D.21192>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21194>; else goto <D.21195>;
      <D.21194>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21196 = 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.21196;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21197 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21197;
      }
      <D.21195>:
      ctx->valid = 0;
      return;
      <D.21193>:
      <D.21191>:
      <D.21188>:
      <D.21186>:
      D.21198 = access | rva;
      if (D.21198 == 0) goto <D.21199>; else goto <D.21200>;
      <D.21199>:
      D.21096 = flags & 8192;
      if (D.21096 == 0) goto <D.21201>; else goto <D.21202>;
      <D.21201>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21203>; else goto <D.21204>;
      <D.21203>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21205 = monoeg_g_strdup_printf ("Invalid method row %d is CompilerControlled but neither RVA != 0 or PinvokeImpl", i);
        vinfo->info.message = D.21205;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21206 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21206;
      }
      <D.21204>:
      ctx->valid = 0;
      return;
      <D.21202>:
      <D.21200>:
      if (rva != 0) goto <D.21207>; else goto <D.21208>;
      <D.21207>:
      D.21211 = flags & 9216;
      if (D.21211 != 0) goto <D.21209>; else goto <D.21212>;
      <D.21212>:
      D.21189 = implflags & 4096;
      if (D.21189 != 0) goto <D.21209>; else goto <D.21210>;
      <D.21209>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21213>; else goto <D.21214>;
      <D.21213>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21215 = monoeg_g_strdup_printf ("Invalid method row %d has RVA != 0 but is either Abstract, InternalCall or PinvokeImpl", i);
        vinfo->info.message = D.21215;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21216 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21216;
      }
      <D.21214>:
      ctx->valid = 0;
      return;
      <D.21210>:
      if (code_type == 2) goto <D.21217>; else goto <D.21218>;
      <D.21217>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21219>; else goto <D.21220>;
      <D.21219>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21221 = 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.21221;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21222 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21222;
      }
      <D.21220>:
      ctx->valid = 0;
      return;
      <D.21218>:
      goto <D.21223>;
      <D.21208>:
      D.21211 = flags & 9216;
      if (D.21211 == 0) goto <D.21224>; else goto <D.21225>;
      <D.21224>:
      D.21189 = implflags & 4096;
      if (D.21189 == 0) goto <D.21226>; else goto <D.21227>;
      <D.21226>:
      if (code_type != 3) goto <D.21228>; else goto <D.21229>;
      <D.21228>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21230>; else goto <D.21231>;
      <D.21230>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21232 = monoeg_g_strdup_printf ("Invalid method row %d has RVA = 0 but neither Abstract, InternalCall, Runtime or PinvokeImpl", i);
        vinfo->info.message = D.21232;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21233 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21233;
      }
      <D.21231>:
      ctx->valid = 0;
      return;
      <D.21229>:
      <D.21227>:
      <D.21225>:
      <D.21223>:
      D.21096 = flags & 8192;
      if (D.21096 != 0) goto <D.21234>; else goto <D.21235>;
      <D.21234>:
      if (rva != 0) goto <D.21236>; else goto <D.21237>;
      <D.21236>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21238>; else goto <D.21239>;
      <D.21238>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21240 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl but has RVA != 0", i);
        vinfo->info.message = D.21240;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21241 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21241;
      }
      <D.21239>:
      ctx->valid = 0;
      return;
      <D.21237>:
      i.44 = (unsigned int) i;
      D.21242 = make_coded_token (56, 6, i.44);
      D.21243 = search_sorted_table (ctx, 28, 1, D.21242);
      if (D.21243 == -1) goto <D.21244>; else goto <D.21245>;
      <D.21244>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21246>; else goto <D.21247>;
      <D.21246>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21248 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl but has no row in the ImplMap table", i);
        vinfo->info.message = D.21248;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21249 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21249;
      }
      <D.21247>:
      ctx->valid = 0;
      return;
      <D.21245>:
      <D.21235>:
      D.21250 = flags & 4096;
      if (D.21250 != 0) goto <D.21251>; else goto <D.21252>;
      <D.21251>:
      D.21071 = is_ctor | is_cctor;
      if (D.21071 == 0) goto <D.21253>; else goto <D.21254>;
      <D.21253>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21255>; else goto <D.21256>;
      <D.21255>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21257 = monoeg_g_strdup_printf ("Invalid method row %d is RtSpecialName but not named .ctor or .cctor", i);
        vinfo->info.message = D.21257;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21258 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21258;
      }
      <D.21256>:
      ctx->valid = 0;
      return;
      <D.21254>:
      <D.21252>:
      D.21071 = is_ctor | is_cctor;
      if (D.21071 != 0) goto <D.21259>; else goto <D.21260>;
      <D.21259>:
      D.21250 = flags & 4096;
      if (D.21250 == 0) goto <D.21261>; else goto <D.21262>;
      <D.21261>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21263>; else goto <D.21264>;
      <D.21263>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21265 = monoeg_g_strdup_printf ("Invalid method row %d is named .ctor or .cctor but is not RtSpecialName", i);
        vinfo->info.message = D.21265;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21266 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21266;
      }
      <D.21264>:
      ctx->valid = 0;
      return;
      <D.21262>:
      <D.21260>:
      D.21267 = data[4];
      if (D.21267 != 0) goto <D.21268>; else goto <D.21269>;
      <D.21268>:
      D.21267 = data[4];
      D.21270 = is_valid_blob_object (ctx, D.21267, 1);
      if (D.21270 == 0) goto <D.21271>; else goto <D.21272>;
      <D.21271>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21273>; else goto <D.21274>;
      <D.21273>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21267 = data[4];
        D.21275 = monoeg_g_strdup_printf ("Invalid method row %d invalid signature blob token 0x%x", i, D.21267);
        vinfo->info.message = D.21275;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21276 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21276;
      }
      <D.21274>:
      ctx->valid = 0;
      return;
      <D.21272>:
      <D.21269>:
      D.21277 = data[5];
      if (D.21277 == 0) goto <D.21278>; else goto <D.21279>;
      <D.21278>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21280>; else goto <D.21281>;
      <D.21280>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21282 = monoeg_g_strdup_printf ("Invalid method row %d ParamList be be >= 1", i);
        vinfo->info.message = D.21282;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21283 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21283;
      }
      <D.21281>:
      ctx->valid = 0;
      return;
      <D.21279>:
      D.21277 = data[5];
      if (D.21277 < paramlist) goto <D.21284>; else goto <D.21285>;
      <D.21284>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21286>; else goto <D.21287>;
      <D.21286>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21277 = data[5];
        D.21288 = monoeg_g_strdup_printf ("Invalid method row %d ParamList rowid 0x%08x can\'t be smaller than of previous row 0x%08x", i, D.21277, paramlist);
        vinfo->info.message = D.21288;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21289 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21289;
      }
      <D.21287>:
      ctx->valid = 0;
      return;
      <D.21285>:
      D.21277 = data[5];
      D.20960 = ctx->image;
      D.21290 = D.20960->tables[8].rows;
      D.21291 = (int) D.21290;
      D.21292 = D.21291 + 1;
      D.21293 = (unsigned int) D.21292;
      if (D.21277 > D.21293) goto <D.21294>; else goto <D.21295>;
      <D.21294>:
      D.20968 = ctx->report_error;
      if (D.20968 != 0) goto <D.21296>; else goto <D.21297>;
      <D.21296>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21277 = data[5];
        D.21298 = monoeg_g_strdup_printf ("Invalid method row %d ParamList rowid 0x%08x is out of range", i, D.21277);
        vinfo->info.message = D.21298;
        vinfo->exception_type = 3;
        D.20972 = ctx->errors;
        D.21299 = monoeg_g_slist_prepend (D.20972, vinfo);
        ctx->errors = D.21299;
      }
      <D.21297>:
      ctx->valid = 0;
      return;
      <D.21295>:
      paramlist = data[5];
      i = i + 1;
      <D.18526>:
      D.21300 = table->rows;
      D.21301 = (int) D.21300;
      if (D.21301 > i) goto <D.18525>; else goto <D.18527>;
      <D.18527>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


get_string_ptr (struct VerifyContext * ctx, guint offset)
{
  const char * D.21305;
  struct MonoImage * D.21306;
  const char * D.21307;

  D.21306 = ctx->image;
  D.21307 = D.21306->heap_strings.data;
  D.21305 = D.21307 + offset;
  return D.21305;
}


verify_param_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21309;
  unsigned int D.21310;
  unsigned int D.21311;
  <unnamed-unsigned:24> D.21314;
  int D.21315;
  int D.21318;
  gchar * D.21321;
  struct GSList * D.21322;
  struct GSList * D.21323;
  unsigned int D.21324;
  gchar * D.21329;
  struct GSList * D.21330;
  unsigned int i.45;
  unsigned int D.21332;
  int D.21333;
  unsigned int D.21336;
  gchar * D.21341;
  struct GSList * D.21342;
  gchar * D.21348;
  struct GSList * D.21349;
  unsigned int D.21350;
  unsigned int D.21353;
  int D.21354;
  gchar * D.21359;
  struct GSList * D.21360;
  unsigned int D.21361;
  int D.21362;
  gchar * D.21367;
  struct GSList * D.21368;
  unsigned int D.21371;
  gchar * D.21376;
  struct GSList * D.21377;
  struct MonoTableInfo * table;
  guint32 data[3];
  guint32 flags;
  guint32 sequence;
  guint32 remaining_params;
  guint32 current_method;
  gboolean first_param;
  int i;

  try
    {
      D.21309 = ctx->image;
      table = &D.21309->tables[8];
      sequence = 0;
      current_method = 0;
      first_param = 1;
      D.21309 = ctx->image;
      D.21310 = BIT_FIELD_REF <*D.21309, 32, 1408>;
      D.21311 = D.21310 & 16777215;
      if (D.21311 == 0) goto <D.21312>; else goto <D.21313>;
      <D.21312>:
      D.21314 = table->rows;
      D.21315 = (int) D.21314;
      if (D.21315 > 0) goto <D.21316>; else goto <D.21317>;
      <D.21316>:
      D.21318 = ctx->report_error;
      if (D.21318 != 0) goto <D.21319>; else goto <D.21320>;
      <D.21319>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21321 = monoeg_strdup ("Param table has rows while the method table has zero");
        vinfo->info.message = D.21321;
        vinfo->exception_type = 3;
        D.21322 = ctx->errors;
        D.21323 = monoeg_g_slist_prepend (D.21322, vinfo);
        ctx->errors = D.21323;
      }
      <D.21320>:
      ctx->valid = 0;
      return;
      <D.21317>:
      return;
      <D.21313>:
      remaining_params = get_next_param_count (ctx, &current_method);
      i = 0;
      goto <D.18571>;
      <D.18570>:
      mono_metadata_decode_row (table, i, &data, 3);
      flags = data[0];
      D.21324 = flags & 53228;
      if (D.21324 != 0) goto <D.21325>; else goto <D.21326>;
      <D.21325>:
      D.21318 = ctx->report_error;
      if (D.21318 != 0) goto <D.21327>; else goto <D.21328>;
      <D.21327>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21329 = monoeg_g_strdup_printf ("Invalid param row %d bad Flags value 0x%08x", i, flags);
        vinfo->info.message = D.21329;
        vinfo->exception_type = 3;
        D.21322 = ctx->errors;
        D.21330 = monoeg_g_slist_prepend (D.21322, vinfo);
        ctx->errors = D.21330;
      }
      <D.21328>:
      ctx->valid = 0;
      return;
      <D.21326>:
      i.45 = (unsigned int) i;
      D.21332 = make_coded_token (5, 8, i.45);
      D.21333 = search_sorted_table (ctx, 11, 2, D.21332);
      if (D.21333 == -1) goto <D.21334>; else goto <D.21335>;
      <D.21334>:
      D.21336 = flags & 4096;
      if (D.21336 != 0) goto <D.21337>; else goto <D.21338>;
      <D.21337>:
      D.21318 = ctx->report_error;
      if (D.21318 != 0) goto <D.21339>; else goto <D.21340>;
      <D.21339>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21341 = monoeg_g_strdup_printf ("Invalid param row %d HasDefault = 1 but no owned row in Contant table", i);
        vinfo->info.message = D.21341;
        vinfo->exception_type = 3;
        D.21322 = ctx->errors;
        D.21342 = monoeg_g_slist_prepend (D.21322, vinfo);
        ctx->errors = D.21342;
      }
      <D.21340>:
      ctx->valid = 0;
      return;
      <D.21338>:
      goto <D.21343>;
      <D.21335>:
      D.21336 = flags & 4096;
      if (D.21336 == 0) goto <D.21344>; else goto <D.21345>;
      <D.21344>:
      D.21318 = ctx->report_error;
      if (D.21318 != 0) goto <D.21346>; else goto <D.21347>;
      <D.21346>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21348 = monoeg_g_strdup_printf ("Invalid param row %d HasDefault = 0 but has owned row in Contant table", i);
        vinfo->info.message = D.21348;
        vinfo->exception_type = 3;
        D.21322 = ctx->errors;
        D.21349 = monoeg_g_slist_prepend (D.21322, vinfo);
        ctx->errors = D.21349;
      }
      <D.21347>:
      ctx->valid = 0;
      return;
      <D.21345>:
      <D.21343>:
      D.21350 = flags & 8192;
      if (D.21350 != 0) goto <D.21351>; else goto <D.21352>;
      <D.21351>:
      i.45 = (unsigned int) i;
      D.21353 = make_coded_token (32, 8, i.45);
      D.21354 = search_sorted_table (ctx, 13, 0, D.21353);
      if (D.21354 == -1) goto <D.21355>; else goto <D.21356>;
      <D.21355>:
      D.21318 = ctx->report_error;
      if (D.21318 != 0) goto <D.21357>; else goto <D.21358>;
      <D.21357>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21359 = monoeg_g_strdup_printf ("Invalid param row %d HasFieldMarshal = 1 but no owned row in FieldMarshal table", i);
        vinfo->info.message = D.21359;
        vinfo->exception_type = 3;
        D.21322 = ctx->errors;
        D.21360 = monoeg_g_slist_prepend (D.21322, vinfo);
        ctx->errors = D.21360;
      }
      <D.21358>:
      ctx->valid = 0;
      return;
      <D.21356>:
      <D.21352>:
      D.21361 = data[2];
      D.21362 = is_valid_string (ctx, D.21361);
      if (D.21362 == 0) goto <D.21363>; else goto <D.21364>;
      <D.21363>:
      D.21318 = ctx->report_error;
      if (D.21318 != 0) goto <D.21365>; else goto <D.21366>;
      <D.21365>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21361 = data[2];
        D.21367 = monoeg_g_strdup_printf ("Invalid param row %d Name = 1 bad token 0x%08x", i, D.21361);
        vinfo->info.message = D.21367;
        vinfo->exception_type = 3;
        D.21322 = ctx->errors;
        D.21368 = monoeg_g_slist_prepend (D.21322, vinfo);
        ctx->errors = D.21368;
      }
      <D.21366>:
      ctx->valid = 0;
      return;
      <D.21364>:
      if (first_param == 0) goto <D.21369>; else goto <D.21370>;
      <D.21369>:
      D.21371 = data[1];
      if (D.21371 <= sequence) goto <D.21372>; else goto <D.21373>;
      <D.21372>:
      D.21318 = ctx->report_error;
      if (D.21318 != 0) goto <D.21374>; else goto <D.21375>;
      <D.21374>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21371 = data[1];
        D.21376 = monoeg_g_strdup_printf ("Invalid param row %d sequece = %d previus param has %d", i, D.21371, sequence);
        vinfo->info.message = D.21376;
        vinfo->exception_type = 3;
        D.21322 = ctx->errors;
        D.21377 = monoeg_g_slist_prepend (D.21322, vinfo);
        ctx->errors = D.21377;
      }
      <D.21375>:
      ctx->valid = 0;
      return;
      <D.21373>:
      <D.21370>:
      first_param = 0;
      sequence = data[1];
      remaining_params = remaining_params + 4294967295;
      if (remaining_params == 0) goto <D.21378>; else goto <D.21379>;
      <D.21378>:
      remaining_params = get_next_param_count (ctx, &current_method);
      first_param = 1;
      <D.21379>:
      i = i + 1;
      <D.18571>:
      D.21314 = table->rows;
      D.21315 = (int) D.21314;
      if (D.21315 > i) goto <D.18570>; else goto <D.18572>;
      <D.18572>:
    }
  finally
    {
      data = {CLOBBER};
      current_method = {CLOBBER};
    }
}


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

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


get_next_param_count (struct VerifyContext * ctx, guint32 * current_method)
{
  struct MonoImage * D.21385;
  unsigned int row.46;
  int row.47;
  int row.48;
  guint32 D.21391;
  <unnamed-unsigned:24> D.21392;
  unsigned int D.21393;
  struct MonoTableInfo * table;
  guint32 row;
  guint32 paramlist;
  guint32 tmp;

  D.21385 = ctx->image;
  table = &D.21385->tables[6];
  row = *current_method;
  row.46 = row;
  row = row.46 + 1;
  row.47 = (int) row.46;
  paramlist = mono_metadata_decode_row_col (table, row.47, 5);
  goto <D.18550>;
  <D.18549>:
  row.48 = (int) row;
  tmp = mono_metadata_decode_row_col (table, row.48, 5);
  if (tmp > paramlist) goto <D.21389>; else goto <D.21390>;
  <D.21389>:
  *current_method = row;
  D.21391 = tmp - paramlist;
  return D.21391;
  <D.21390>:
  row = row + 1;
  <D.18550>:
  D.21392 = table->rows;
  D.21393 = (unsigned int) D.21392;
  if (D.21393 > row) goto <D.18549>; else goto <D.18551>;
  <D.18551>:
  D.21392 = table->rows;
  D.21393 = (unsigned int) D.21392;
  *current_method = D.21393;
  D.21391 = 4294967295;
  return D.21391;
}


verify_interfaceimpl_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21395;
  unsigned int D.21396;
  <unnamed-unsigned:24> D.21399;
  unsigned int D.21400;
  int D.21403;
  gchar * D.21406;
  struct GSList * D.21407;
  struct GSList * D.21408;
  unsigned int D.21409;
  int D.21410;
  gchar * D.21415;
  struct GSList * D.21416;
  unsigned int D.21417;
  gchar * D.21422;
  struct GSList * D.21423;
  <unnamed-unsigned:24> D.21424;
  int D.21425;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.21395 = ctx->image;
      table = &D.21395->tables[9];
      i = 0;
      goto <D.18583>;
      <D.18582>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.21396 = data[0];
      if (D.21396 != 0) goto <D.21397>; else goto <D.21398>;
      <D.21397>:
      D.21396 = data[0];
      D.21395 = ctx->image;
      D.21399 = D.21395->tables[2].rows;
      D.21400 = (unsigned int) D.21399;
      if (D.21396 > D.21400) goto <D.21401>; else goto <D.21402>;
      <D.21401>:
      D.21403 = ctx->report_error;
      if (D.21403 != 0) goto <D.21404>; else goto <D.21405>;
      <D.21404>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21396 = data[0];
        D.21406 = monoeg_g_strdup_printf ("Invalid InterfaceImpl row %d Class field 0x%08x", i, D.21396);
        vinfo->info.message = D.21406;
        vinfo->exception_type = 3;
        D.21407 = ctx->errors;
        D.21408 = monoeg_g_slist_prepend (D.21407, vinfo);
        ctx->errors = D.21408;
      }
      <D.21405>:
      ctx->valid = 0;
      return;
      <D.21402>:
      <D.21398>:
      D.21409 = data[1];
      D.21410 = is_valid_coded_index (ctx, 0, D.21409);
      if (D.21410 == 0) goto <D.21411>; else goto <D.21412>;
      <D.21411>:
      D.21403 = ctx->report_error;
      if (D.21403 != 0) goto <D.21413>; else goto <D.21414>;
      <D.21413>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21409 = data[1];
        D.21415 = monoeg_g_strdup_printf ("Invalid InterfaceImpl row %d Inteface field coded index 0x%08x", i, D.21409);
        vinfo->info.message = D.21415;
        vinfo->exception_type = 3;
        D.21407 = ctx->errors;
        D.21416 = monoeg_g_slist_prepend (D.21407, vinfo);
        ctx->errors = D.21416;
      }
      <D.21414>:
      ctx->valid = 0;
      return;
      <D.21412>:
      D.21409 = data[1];
      D.21417 = get_coded_index_token (0, D.21409);
      if (D.21417 == 0) goto <D.21418>; else goto <D.21419>;
      <D.21418>:
      D.21403 = ctx->report_error;
      if (D.21403 != 0) goto <D.21420>; else goto <D.21421>;
      <D.21420>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21422 = monoeg_g_strdup_printf ("Invalid InterfaceImpl row %d Inteface field is null", i);
        vinfo->info.message = D.21422;
        vinfo->exception_type = 3;
        D.21407 = ctx->errors;
        D.21423 = monoeg_g_slist_prepend (D.21407, vinfo);
        ctx->errors = D.21423;
      }
      <D.21421>:
      ctx->valid = 0;
      return;
      <D.21419>:
      i = i + 1;
      <D.18583>:
      D.21424 = table->rows;
      D.21425 = (int) D.21424;
      if (D.21425 > i) goto <D.18582>; else goto <D.18584>;
      <D.18584>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_memberref_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21429;
  unsigned int D.21430;
  int D.21431;
  int D.21434;
  gchar * D.21437;
  struct GSList * D.21438;
  struct GSList * D.21439;
  unsigned int D.21440;
  gchar * D.21445;
  struct GSList * D.21446;
  unsigned int D.21447;
  int D.21448;
  gchar * D.21453;
  struct GSList * D.21454;
  unsigned int D.21455;
  int D.21458;
  gchar * D.21463;
  struct GSList * D.21464;
  <unnamed-unsigned:24> D.21465;
  int D.21466;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.21429 = ctx->image;
      table = &D.21429->tables[10];
      i = 0;
      goto <D.18596>;
      <D.18595>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.21430 = data[0];
      D.21431 = is_valid_coded_index (ctx, 41, D.21430);
      if (D.21431 == 0) goto <D.21432>; else goto <D.21433>;
      <D.21432>:
      D.21434 = ctx->report_error;
      if (D.21434 != 0) goto <D.21435>; else goto <D.21436>;
      <D.21435>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21430 = data[0];
        D.21437 = monoeg_g_strdup_printf ("Invalid MemberRef row %d Class field coded index 0x%08x", i, D.21430);
        vinfo->info.message = D.21437;
        vinfo->exception_type = 3;
        D.21438 = ctx->errors;
        D.21439 = monoeg_g_slist_prepend (D.21438, vinfo);
        ctx->errors = D.21439;
      }
      <D.21436>:
      ctx->valid = 0;
      return;
      <D.21433>:
      D.21430 = data[0];
      D.21440 = get_coded_index_token (41, D.21430);
      if (D.21440 == 0) goto <D.21441>; else goto <D.21442>;
      <D.21441>:
      D.21434 = ctx->report_error;
      if (D.21434 != 0) goto <D.21443>; else goto <D.21444>;
      <D.21443>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21445 = monoeg_g_strdup_printf ("Invalid MemberRef row %d Class field coded is null", i);
        vinfo->info.message = D.21445;
        vinfo->exception_type = 3;
        D.21438 = ctx->errors;
        D.21446 = monoeg_g_slist_prepend (D.21438, vinfo);
        ctx->errors = D.21446;
      }
      <D.21444>:
      ctx->valid = 0;
      return;
      <D.21442>:
      D.21447 = data[1];
      D.21448 = is_valid_non_empty_string (ctx, D.21447);
      if (D.21448 == 0) goto <D.21449>; else goto <D.21450>;
      <D.21449>:
      D.21434 = ctx->report_error;
      if (D.21434 != 0) goto <D.21451>; else goto <D.21452>;
      <D.21451>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21447 = data[1];
        D.21453 = monoeg_g_strdup_printf ("Invalid MemberRef row %d Name field coded is invalid or empty 0x%08x", i, D.21447);
        vinfo->info.message = D.21453;
        vinfo->exception_type = 3;
        D.21438 = ctx->errors;
        D.21454 = monoeg_g_slist_prepend (D.21438, vinfo);
        ctx->errors = D.21454;
      }
      <D.21452>:
      ctx->valid = 0;
      return;
      <D.21450>:
      D.21455 = data[2];
      if (D.21455 != 0) goto <D.21456>; else goto <D.21457>;
      <D.21456>:
      D.21455 = data[2];
      D.21458 = is_valid_blob_object (ctx, D.21455, 1);
      if (D.21458 == 0) goto <D.21459>; else goto <D.21460>;
      <D.21459>:
      D.21434 = ctx->report_error;
      if (D.21434 != 0) goto <D.21461>; else goto <D.21462>;
      <D.21461>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21455 = data[2];
        D.21463 = monoeg_g_strdup_printf ("Invalid MemberRef row %d invalid signature blob token 0x%x", i, D.21455);
        vinfo->info.message = D.21463;
        vinfo->exception_type = 3;
        D.21438 = ctx->errors;
        D.21464 = monoeg_g_slist_prepend (D.21438, vinfo);
        ctx->errors = D.21464;
      }
      <D.21462>:
      ctx->valid = 0;
      return;
      <D.21460>:
      <D.21457>:
      i = i + 1;
      <D.18596>:
      D.21465 = table->rows;
      D.21466 = (int) D.21465;
      if (D.21466 > i) goto <D.18595>; else goto <D.18597>;
      <D.18597>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_constant_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21470;
  unsigned int D.21471;
  _Bool D.21472;
  _Bool D.21473;
  _Bool D.21474;
  int D.21477;
  gchar * D.21480;
  struct GSList * D.21481;
  struct GSList * D.21482;
  unsigned int D.21483;
  int D.21484;
  gchar * D.21489;
  struct GSList * D.21490;
  unsigned int D.21491;
  gchar * D.21496;
  struct GSList * D.21497;
  unsigned int D.21498;
  int D.21499;
  gchar * D.21504;
  struct GSList * D.21505;
  <unnamed-unsigned:24> D.21506;
  int D.21507;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 type;
  int i;

  try
    {
      D.21470 = ctx->image;
      table = &D.21470->tables[11];
      i = 0;
      goto <D.18620>;
      <D.18619>:
      mono_metadata_decode_row (table, i, &data, 4);
      type = data[0];
      D.21471 = type + 4294967294;
      D.21472 = D.21471 > 12;
      D.21473 = type != 18;
      D.21474 = D.21472 & D.21473;
      if (D.21474 != 0) goto <D.21475>; else goto <D.21476>;
      <D.21475>:
      D.21477 = ctx->report_error;
      if (D.21477 != 0) goto <D.21478>; else goto <D.21479>;
      <D.21478>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21480 = monoeg_g_strdup_printf ("Invalid Constant row %d Type field 0x%08x", i, type);
        vinfo->info.message = D.21480;
        vinfo->exception_type = 3;
        D.21481 = ctx->errors;
        D.21482 = monoeg_g_slist_prepend (D.21481, vinfo);
        ctx->errors = D.21482;
      }
      <D.21479>:
      ctx->valid = 0;
      return;
      <D.21476>:
      D.21483 = data[2];
      D.21484 = is_valid_coded_index (ctx, 5, D.21483);
      if (D.21484 == 0) goto <D.21485>; else goto <D.21486>;
      <D.21485>:
      D.21477 = ctx->report_error;
      if (D.21477 != 0) goto <D.21487>; else goto <D.21488>;
      <D.21487>:
      {
        struct MonoVerifyInfoExtended * vinfo;

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

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21496 = monoeg_g_strdup_printf ("Invalid Constant row %d Parent field coded is null", i);
        vinfo->info.message = D.21496;
        vinfo->exception_type = 3;
        D.21481 = ctx->errors;
        D.21497 = monoeg_g_slist_prepend (D.21481, vinfo);
        ctx->errors = D.21497;
      }
      <D.21495>:
      ctx->valid = 0;
      return;
      <D.21493>:
      D.21498 = data[3];
      D.21499 = is_valid_constant (ctx, type, D.21498);
      if (D.21499 == 0) goto <D.21500>; else goto <D.21501>;
      <D.21500>:
      D.21477 = ctx->report_error;
      if (D.21477 != 0) goto <D.21502>; else goto <D.21503>;
      <D.21502>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21498 = data[3];
        D.21504 = monoeg_g_strdup_printf ("Invalid Constant row %d Value field 0x%08x", i, D.21498);
        vinfo->info.message = D.21504;
        vinfo->exception_type = 3;
        D.21481 = ctx->errors;
        D.21505 = monoeg_g_slist_prepend (D.21481, vinfo);
        ctx->errors = D.21505;
      }
      <D.21503>:
      ctx->valid = 0;
      return;
      <D.21501>:
      i = i + 1;
      <D.18620>:
      D.21506 = table->rows;
      D.21507 = (int) D.21506;
      if (D.21507 > i) goto <D.18619>; else goto <D.18621>;
      <D.18621>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_constant (struct VerifyContext * ctx, guint32 type, guint32 offset)
{
  struct MonoImage * D.21511;
  struct MonoStreamHeader * D.21512;
  unsigned int D.21513;
  int D.21516;
  gchar * D.21519;
  struct GSList * D.21520;
  struct GSList * D.21521;
  gboolean D.21522;
  unsigned int D.21523;
  unsigned int D.21524;
  const char * D.21525;
  sizetype D.21526;
  const char * D.21527;
  int D.21528;
  gchar * D.21533;
  struct GSList * D.21534;
  unsigned int bytes.49;
  unsigned int entry_size.50;
  unsigned int D.21541;
  unsigned int D.21543;
  unsigned int D.21546;
  unsigned int D.21547;
  gchar * D.21548;
  struct GSList * D.21549;
  gchar * D.21554;
  struct GSList * D.21555;
  unsigned int D.21558;
  unsigned int D.21560;
  gchar * D.21563;
  struct GSList * D.21564;
  unsigned int D.21567;
  gchar * D.21572;
  struct GSList * D.21573;
  struct OffsetAndSize blob;
  guint32 size;
  guint32 entry_size;
  guint32 bytes;

  try
    {
      D.21511 = ctx->image;
      D.21512 = &D.21511->heap_blob;
      blob = get_metadata_stream (ctx, D.21512); [return slot optimization]
      D.21513 = blob.size;
      if (D.21513 < offset) goto <D.21514>; else goto <D.21515>;
      <D.21514>:
      D.21516 = ctx->report_error;
      if (D.21516 != 0) goto <D.21517>; else goto <D.21518>;
      <D.21517>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21519 = monoeg_strdup ("ContantValue: invalid offset");
        vinfo->info.message = D.21519;
        vinfo->exception_type = 3;
        D.21520 = ctx->errors;
        D.21521 = monoeg_g_slist_prepend (D.21520, vinfo);
        ctx->errors = D.21521;
      }
      <D.21518>:
      ctx->valid = 0;
      D.21522 = 0;
      return D.21522;
      <D.21515>:
      D.21513 = blob.size;
      D.21523 = blob.offset;
      D.21524 = D.21513 - D.21523;
      D.21525 = ctx->data;
      D.21523 = blob.offset;
      D.21526 = D.21523 + offset;
      D.21527 = D.21525 + D.21526;
      D.21528 = decode_value (D.21527, D.21524, &entry_size, &bytes);
      if (D.21528 == 0) goto <D.21529>; else goto <D.21530>;
      <D.21529>:
      D.21516 = ctx->report_error;
      if (D.21516 != 0) goto <D.21531>; else goto <D.21532>;
      <D.21531>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21533 = monoeg_strdup ("ContantValue: not enough space to decode size");
        vinfo->info.message = D.21533;
        vinfo->exception_type = 3;
        D.21520 = ctx->errors;
        D.21534 = monoeg_g_slist_prepend (D.21520, vinfo);
        ctx->errors = D.21534;
      }
      <D.21532>:
      ctx->valid = 0;
      D.21522 = 0;
      return D.21522;
      <D.21530>:
      if (type == 14) goto <D.21535>; else goto <D.21536>;
      <D.21535>:
      bytes.49 = bytes;
      offset = offset + bytes.49;
      entry_size.50 = entry_size;
      D.21541 = offset + entry_size.50;
      D.21513 = blob.size;
      if (D.21541 > D.21513) goto <D.21538>; else goto <D.21542>;
      <D.21542>:
      entry_size.50 = entry_size;
      D.21543 = ~entry_size.50;
      if (D.21543 < offset) goto <D.21538>; else goto <D.21539>;
      <D.21538>:
      D.21516 = ctx->report_error;
      if (D.21516 != 0) goto <D.21544>; else goto <D.21545>;
      <D.21544>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21513 = blob.size;
        D.21546 = D.21513 - offset;
        entry_size.50 = entry_size;
        D.21547 = entry_size.50 * 2;
        D.21548 = monoeg_g_strdup_printf ("ContantValue: not enough space for string, required %d but got %d", D.21547, D.21546);
        vinfo->info.message = D.21548;
        vinfo->exception_type = 3;
        D.21520 = ctx->errors;
        D.21549 = monoeg_g_slist_prepend (D.21520, vinfo);
        ctx->errors = D.21549;
      }
      <D.21545>:
      ctx->valid = 0;
      D.21522 = 0;
      return D.21522;
      <D.21539>:
      D.21522 = 1;
      return D.21522;
      <D.21536>:
      switch (type) <default: <D.18305>, case 2: <D.18291>, case 3: <D.18295>, case 4: <D.18292>, case 5: <D.18293>, case 6: <D.18296>, case 7: <D.18297>, case 8: <D.18298>, case 9: <D.18299>, case 10: <D.18302>, case 11: <D.18303>, case 12: <D.18300>, case 13: <D.18304>, case 18: <D.18301>>
      <D.18291>:
      <D.18292>:
      <D.18293>:
      size = 1;
      goto <D.18294>;
      <D.18295>:
      <D.18296>:
      <D.18297>:
      size = 2;
      goto <D.18294>;
      <D.18298>:
      <D.18299>:
      <D.18300>:
      <D.18301>:
      size = 4;
      goto <D.18294>;
      <D.18302>:
      <D.18303>:
      <D.18304>:
      size = 8;
      goto <D.18294>;
      <D.18305>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata-verify.c", 2221);
      <D.18294>:
      entry_size.50 = entry_size;
      if (size != entry_size.50) goto <D.21550>; else goto <D.21551>;
      <D.21550>:
      D.21516 = ctx->report_error;
      if (D.21516 != 0) goto <D.21552>; else goto <D.21553>;
      <D.21552>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        entry_size.50 = entry_size;
        D.21554 = monoeg_g_strdup_printf ("ContantValue: Expected size %d but got %d", size, entry_size.50);
        vinfo->info.message = D.21554;
        vinfo->exception_type = 3;
        D.21520 = ctx->errors;
        D.21555 = monoeg_g_slist_prepend (D.21520, vinfo);
        ctx->errors = D.21555;
      }
      <D.21553>:
      ctx->valid = 0;
      D.21522 = 0;
      return D.21522;
      <D.21551>:
      bytes.49 = bytes;
      offset = offset + bytes.49;
      D.21558 = offset + size;
      D.21513 = blob.size;
      if (D.21558 > D.21513) goto <D.21556>; else goto <D.21559>;
      <D.21559>:
      D.21560 = ~size;
      if (D.21560 < offset) goto <D.21556>; else goto <D.21557>;
      <D.21556>:
      D.21516 = ctx->report_error;
      if (D.21516 != 0) goto <D.21561>; else goto <D.21562>;
      <D.21561>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21513 = blob.size;
        D.21546 = D.21513 - offset;
        D.21563 = monoeg_g_strdup_printf ("ContantValue: Not enough room for constant, required %d but have %d", size, D.21546);
        vinfo->info.message = D.21563;
        vinfo->exception_type = 3;
        D.21520 = ctx->errors;
        D.21564 = monoeg_g_slist_prepend (D.21520, vinfo);
        ctx->errors = D.21564;
      }
      <D.21562>:
      ctx->valid = 0;
      D.21522 = 0;
      return D.21522;
      <D.21557>:
      if (type == 18) goto <D.21565>; else goto <D.21566>;
      <D.21565>:
      D.21525 = ctx->data;
      D.21523 = blob.offset;
      D.21526 = D.21523 + offset;
      D.21527 = D.21525 + D.21526;
      D.21567 = MEM[(const guint32 *)D.21527];
      if (D.21567 != 0) goto <D.21568>; else goto <D.21569>;
      <D.21568>:
      D.21516 = ctx->report_error;
      if (D.21516 != 0) goto <D.21570>; else goto <D.21571>;
      <D.21570>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21572 = monoeg_g_strdup_printf ("ContantValue: Type is class but value is not null");
        vinfo->info.message = D.21572;
        vinfo->exception_type = 3;
        D.21520 = ctx->errors;
        D.21573 = monoeg_g_slist_prepend (D.21520, vinfo);
        ctx->errors = D.21573;
      }
      <D.21571>:
      ctx->valid = 0;
      D.21522 = 0;
      return D.21522;
      <D.21569>:
      <D.21566>:
      D.21522 = 1;
      return D.21522;
    }
  finally
    {
      blob = {CLOBBER};
      entry_size = {CLOBBER};
      bytes = {CLOBBER};
    }
}


verify_cattr_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21576;
  unsigned int D.21577;
  int D.21578;
  int D.21581;
  gchar * D.21584;
  struct GSList * D.21585;
  struct GSList * D.21586;
  unsigned int D.21589;
  int D.21590;
  unsigned int D.21592;
  gchar * D.21595;
  struct GSList * D.21596;
  unsigned int D.21597;
  int D.21600;
  gchar * D.21605;
  struct GSList * D.21606;
  <unnamed-unsigned:24> D.21607;
  int D.21608;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.21576 = ctx->image;
      table = &D.21576->tables[12];
      i = 0;
      goto <D.18632>;
      <D.18631>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.21577 = data[0];
      D.21578 = is_valid_coded_index (ctx, 10, D.21577);
      if (D.21578 == 0) goto <D.21579>; else goto <D.21580>;
      <D.21579>:
      D.21581 = ctx->report_error;
      if (D.21581 != 0) goto <D.21582>; else goto <D.21583>;
      <D.21582>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21577 = data[0];
        D.21584 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d Parent field 0x%08x", i, D.21577);
        vinfo->info.message = D.21584;
        vinfo->exception_type = 3;
        D.21585 = ctx->errors;
        D.21586 = monoeg_g_slist_prepend (D.21585, vinfo);
        ctx->errors = D.21586;
      }
      <D.21583>:
      ctx->valid = 0;
      return;
      <D.21580>:
      D.21589 = data[1];
      D.21590 = is_valid_coded_index (ctx, 65, D.21589);
      if (D.21590 == 0) goto <D.21587>; else goto <D.21591>;
      <D.21591>:
      D.21589 = data[1];
      D.21592 = get_coded_index_token (65, D.21589);
      if (D.21592 == 0) goto <D.21587>; else goto <D.21588>;
      <D.21587>:
      D.21581 = ctx->report_error;
      if (D.21581 != 0) goto <D.21593>; else goto <D.21594>;
      <D.21593>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21589 = data[1];
        D.21595 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d Type field 0x%08x", i, D.21589);
        vinfo->info.message = D.21595;
        vinfo->exception_type = 3;
        D.21585 = ctx->errors;
        D.21596 = monoeg_g_slist_prepend (D.21585, vinfo);
        ctx->errors = D.21596;
      }
      <D.21594>:
      ctx->valid = 0;
      return;
      <D.21588>:
      D.21597 = data[2];
      if (D.21597 != 0) goto <D.21598>; else goto <D.21599>;
      <D.21598>:
      D.21597 = data[2];
      D.21600 = is_valid_blob_object (ctx, D.21597, 0);
      if (D.21600 == 0) goto <D.21601>; else goto <D.21602>;
      <D.21601>:
      D.21581 = ctx->report_error;
      if (D.21581 != 0) goto <D.21603>; else goto <D.21604>;
      <D.21603>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21597 = data[2];
        D.21605 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d invalid value blob 0x%x", i, D.21597);
        vinfo->info.message = D.21605;
        vinfo->exception_type = 3;
        D.21585 = ctx->errors;
        D.21606 = monoeg_g_slist_prepend (D.21585, vinfo);
        ctx->errors = D.21606;
      }
      <D.21604>:
      ctx->valid = 0;
      return;
      <D.21602>:
      <D.21599>:
      i = i + 1;
      <D.18632>:
      D.21607 = table->rows;
      D.21608 = (int) D.21607;
      if (D.21608 > i) goto <D.18631>; else goto <D.18633>;
      <D.18633>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_field_marshal_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21612;
  unsigned int D.21613;
  int D.21614;
  int D.21617;
  gchar * D.21620;
  struct GSList * D.21621;
  struct GSList * D.21622;
  unsigned int D.21623;
  gchar * D.21628;
  struct GSList * D.21629;
  unsigned int D.21630;
  gchar * D.21635;
  struct GSList * D.21636;
  int D.21637;
  gchar * D.21642;
  struct GSList * D.21643;
  <unnamed-unsigned:24> D.21644;
  int D.21645;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.21612 = ctx->image;
      table = &D.21612->tables[13];
      i = 0;
      goto <D.18665>;
      <D.18664>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.21613 = data[0];
      D.21614 = is_valid_coded_index (ctx, 32, D.21613);
      if (D.21614 == 0) goto <D.21615>; else goto <D.21616>;
      <D.21615>:
      D.21617 = ctx->report_error;
      if (D.21617 != 0) goto <D.21618>; else goto <D.21619>;
      <D.21618>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21613 = data[0];
        D.21620 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d Parent field 0x%08x", i, D.21613);
        vinfo->info.message = D.21620;
        vinfo->exception_type = 3;
        D.21621 = ctx->errors;
        D.21622 = monoeg_g_slist_prepend (D.21621, vinfo);
        ctx->errors = D.21622;
      }
      <D.21619>:
      ctx->valid = 0;
      return;
      <D.21616>:
      D.21613 = data[0];
      D.21623 = get_coded_index_token (32, D.21613);
      if (D.21623 == 0) goto <D.21624>; else goto <D.21625>;
      <D.21624>:
      D.21617 = ctx->report_error;
      if (D.21617 != 0) goto <D.21626>; else goto <D.21627>;
      <D.21626>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21628 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d Parent field is null", i);
        vinfo->info.message = D.21628;
        vinfo->exception_type = 3;
        D.21621 = ctx->errors;
        D.21629 = monoeg_g_slist_prepend (D.21621, vinfo);
        ctx->errors = D.21629;
      }
      <D.21627>:
      ctx->valid = 0;
      return;
      <D.21625>:
      D.21630 = data[1];
      if (D.21630 == 0) goto <D.21631>; else goto <D.21632>;
      <D.21631>:
      D.21617 = ctx->report_error;
      if (D.21617 != 0) goto <D.21633>; else goto <D.21634>;
      <D.21633>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21635 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d NativeType field is null", i);
        vinfo->info.message = D.21635;
        vinfo->exception_type = 3;
        D.21621 = ctx->errors;
        D.21636 = monoeg_g_slist_prepend (D.21621, vinfo);
        ctx->errors = D.21636;
      }
      <D.21634>:
      ctx->valid = 0;
      return;
      <D.21632>:
      D.21630 = data[1];
      D.21637 = is_valid_blob_object (ctx, D.21630, 1);
      if (D.21637 == 0) goto <D.21638>; else goto <D.21639>;
      <D.21638>:
      D.21617 = ctx->report_error;
      if (D.21617 != 0) goto <D.21640>; else goto <D.21641>;
      <D.21640>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21630 = data[1];
        D.21642 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d invalid NativeType blob 0x%x", i, D.21630);
        vinfo->info.message = D.21642;
        vinfo->exception_type = 3;
        D.21621 = ctx->errors;
        D.21643 = monoeg_g_slist_prepend (D.21621, vinfo);
        ctx->errors = D.21643;
      }
      <D.21641>:
      ctx->valid = 0;
      return;
      <D.21639>:
      i = i + 1;
      <D.18665>:
      D.21644 = table->rows;
      D.21645 = (int) D.21644;
      if (D.21645 > i) goto <D.18664>; else goto <D.18666>;
      <D.18666>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_decl_security_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21649;
  unsigned int D.21650;
  int D.21651;
  int D.21654;
  gchar * D.21657;
  struct GSList * D.21658;
  struct GSList * D.21659;
  unsigned int D.21660;
  gchar * D.21665;
  struct GSList * D.21666;
  unsigned int D.21667;
  gchar * D.21672;
  struct GSList * D.21673;
  <unnamed-unsigned:24> D.21674;
  int D.21675;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.21649 = ctx->image;
      table = &D.21649->tables[14];
      i = 0;
      goto <D.18687>;
      <D.18686>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.21650 = data[1];
      D.21651 = is_valid_coded_index (ctx, 36, D.21650);
      if (D.21651 == 0) goto <D.21652>; else goto <D.21653>;
      <D.21652>:
      D.21654 = ctx->report_error;
      if (D.21654 != 0) goto <D.21655>; else goto <D.21656>;
      <D.21655>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21650 = data[1];
        D.21657 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d Parent field 0x%08x", i, D.21650);
        vinfo->info.message = D.21657;
        vinfo->exception_type = 3;
        D.21658 = ctx->errors;
        D.21659 = monoeg_g_slist_prepend (D.21658, vinfo);
        ctx->errors = D.21659;
      }
      <D.21656>:
      ctx->valid = 0;
      return;
      <D.21653>:
      D.21650 = data[1];
      D.21660 = get_coded_index_token (36, D.21650);
      if (D.21660 == 0) goto <D.21661>; else goto <D.21662>;
      <D.21661>:
      D.21654 = ctx->report_error;
      if (D.21654 != 0) goto <D.21663>; else goto <D.21664>;
      <D.21663>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21665 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d Parent field is null", i);
        vinfo->info.message = D.21665;
        vinfo->exception_type = 3;
        D.21658 = ctx->errors;
        D.21666 = monoeg_g_slist_prepend (D.21658, vinfo);
        ctx->errors = D.21666;
      }
      <D.21664>:
      ctx->valid = 0;
      return;
      <D.21662>:
      D.21667 = data[2];
      if (D.21667 == 0) goto <D.21668>; else goto <D.21669>;
      <D.21668>:
      D.21654 = ctx->report_error;
      if (D.21654 != 0) goto <D.21670>; else goto <D.21671>;
      <D.21670>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21672 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d PermissionSet field is null", i);
        vinfo->info.message = D.21672;
        vinfo->exception_type = 3;
        D.21658 = ctx->errors;
        D.21673 = monoeg_g_slist_prepend (D.21658, vinfo);
        ctx->errors = D.21673;
      }
      <D.21671>:
      ctx->valid = 0;
      return;
      <D.21669>:
      i = i + 1;
      <D.18687>:
      D.21674 = table->rows;
      D.21675 = (int) D.21674;
      if (D.21675 > i) goto <D.18686>; else goto <D.18688>;
      <D.18688>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_class_layout_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21679;
  unsigned int D.21682;
  <unnamed-unsigned:24> D.21684;
  int D.21685;
  int D.21686;
  unsigned int D.21687;
  int D.21688;
  gchar * D.21691;
  struct GSList * D.21692;
  struct GSList * D.21693;
  unsigned int D.21694;
  gchar * D.21697;
  struct GSList * D.21698;
  <unnamed-unsigned:24> D.21699;
  int D.21700;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.21679 = ctx->image;
      table = &D.21679->tables[15];
      i = 0;
      goto <D.18719>;
      <D.18718>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.21682 = data[2];
      if (D.21682 == 0) goto <D.21680>; else goto <D.21683>;
      <D.21683>:
      D.21682 = data[2];
      D.21679 = ctx->image;
      D.21684 = D.21679->tables[2].rows;
      D.21685 = (int) D.21684;
      D.21686 = D.21685 + 1;
      D.21687 = (unsigned int) D.21686;
      if (D.21682 > D.21687) goto <D.21680>; else goto <D.21681>;
      <D.21680>:
      D.21688 = ctx->report_error;
      if (D.21688 != 0) goto <D.21689>; else goto <D.21690>;
      <D.21689>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21682 = data[2];
        D.21691 = monoeg_g_strdup_printf ("Invalid ClassLayout row %d Parent field 0x%08x", i, D.21682);
        vinfo->info.message = D.21691;
        vinfo->exception_type = 3;
        D.21692 = ctx->errors;
        D.21693 = monoeg_g_slist_prepend (D.21692, vinfo);
        ctx->errors = D.21693;
      }
      <D.21690>:
      ctx->valid = 0;
      return;
      <D.21681>:
      D.21694 = data[0];
      switch (D.21694) <default: <D.18716>, case 0: <D.18706>, case 1: <D.18707>, case 2: <D.18708>, case 4: <D.18709>, case 8: <D.18710>, case 16: <D.18711>, case 32: <D.18712>, case 64: <D.18713>, case 128: <D.18714>>
      <D.18706>:
      <D.18707>:
      <D.18708>:
      <D.18709>:
      <D.18710>:
      <D.18711>:
      <D.18712>:
      <D.18713>:
      <D.18714>:
      goto <D.18715>;
      <D.18716>:
      D.21688 = ctx->report_error;
      if (D.21688 != 0) goto <D.21695>; else goto <D.21696>;
      <D.21695>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21694 = data[0];
        D.21697 = monoeg_g_strdup_printf ("Invalid ClassLayout row %d Packing field %d", i, D.21694);
        vinfo->info.message = D.21697;
        vinfo->exception_type = 3;
        D.21692 = ctx->errors;
        D.21698 = monoeg_g_slist_prepend (D.21692, vinfo);
        ctx->errors = D.21698;
      }
      <D.21696>:
      ctx->valid = 0;
      return;
      <D.18715>:
      i = i + 1;
      <D.18719>:
      D.21699 = table->rows;
      D.21700 = (int) D.21699;
      if (D.21700 > i) goto <D.18718>; else goto <D.18720>;
      <D.18720>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_field_layout_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21705;
  unsigned int D.21708;
  <unnamed-unsigned:24> D.21710;
  int D.21711;
  int D.21712;
  unsigned int D.21713;
  int D.21714;
  gchar * D.21717;
  struct GSList * D.21718;
  struct GSList * D.21719;
  <unnamed-unsigned:24> D.21720;
  int D.21721;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.21705 = ctx->image;
      table = &D.21705->tables[16];
      i = 0;
      goto <D.18729>;
      <D.18728>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.21708 = data[1];
      if (D.21708 == 0) goto <D.21706>; else goto <D.21709>;
      <D.21709>:
      D.21708 = data[1];
      D.21705 = ctx->image;
      D.21710 = D.21705->tables[4].rows;
      D.21711 = (int) D.21710;
      D.21712 = D.21711 + 1;
      D.21713 = (unsigned int) D.21712;
      if (D.21708 > D.21713) goto <D.21706>; else goto <D.21707>;
      <D.21706>:
      D.21714 = ctx->report_error;
      if (D.21714 != 0) goto <D.21715>; else goto <D.21716>;
      <D.21715>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21708 = data[1];
        D.21717 = monoeg_g_strdup_printf ("Invalid FieldLayout row %d Field field 0x%08x", i, D.21708);
        vinfo->info.message = D.21717;
        vinfo->exception_type = 3;
        D.21718 = ctx->errors;
        D.21719 = monoeg_g_slist_prepend (D.21718, vinfo);
        ctx->errors = D.21719;
      }
      <D.21716>:
      ctx->valid = 0;
      return;
      <D.21707>:
      i = i + 1;
      <D.18729>:
      D.21720 = table->rows;
      D.21721 = (int) D.21720;
      if (D.21721 > i) goto <D.18728>; else goto <D.18730>;
      <D.18730>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_standalonesig_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21725;
  unsigned int D.21726;
  int D.21729;
  int D.21732;
  gchar * D.21735;
  struct GSList * D.21736;
  struct GSList * D.21737;
  <unnamed-unsigned:24> D.21738;
  int D.21739;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.21725 = ctx->image;
      table = &D.21725->tables[17];
      i = 0;
      goto <D.18739>;
      <D.18738>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.21726 = data[0];
      if (D.21726 != 0) goto <D.21727>; else goto <D.21728>;
      <D.21727>:
      D.21726 = data[0];
      D.21729 = is_valid_blob_object (ctx, D.21726, 1);
      if (D.21729 == 0) goto <D.21730>; else goto <D.21731>;
      <D.21730>:
      D.21732 = ctx->report_error;
      if (D.21732 != 0) goto <D.21733>; else goto <D.21734>;
      <D.21733>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21726 = data[0];
        D.21735 = monoeg_g_strdup_printf ("Invalid StandAloneSig row %d invalid signature 0x%x", i, D.21726);
        vinfo->info.message = D.21735;
        vinfo->exception_type = 3;
        D.21736 = ctx->errors;
        D.21737 = monoeg_g_slist_prepend (D.21736, vinfo);
        ctx->errors = D.21737;
      }
      <D.21734>:
      ctx->valid = 0;
      return;
      <D.21731>:
      <D.21728>:
      i = i + 1;
      <D.18739>:
      D.21738 = table->rows;
      D.21739 = (int) D.21738;
      if (D.21739 > i) goto <D.18738>; else goto <D.18740>;
      <D.18740>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_eventmap_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21743;
  unsigned int D.21746;
  <unnamed-unsigned:24> D.21748;
  int D.21749;
  int D.21750;
  unsigned int D.21751;
  int D.21752;
  gchar * D.21755;
  struct GSList * D.21756;
  struct GSList * D.21757;
  unsigned int D.21760;
  gchar * D.21764;
  struct GSList * D.21765;
  <unnamed-unsigned:24> D.21766;
  int D.21767;
  struct MonoTableInfo * table;
  guint32 data[2];
  guint32 eventlist;
  int i;

  try
    {
      D.21743 = ctx->image;
      table = &D.21743->tables[18];
      eventlist = 0;
      i = 0;
      goto <D.18761>;
      <D.18760>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.21746 = data[0];
      if (D.21746 == 0) goto <D.21744>; else goto <D.21747>;
      <D.21747>:
      D.21746 = data[0];
      D.21743 = ctx->image;
      D.21748 = D.21743->tables[2].rows;
      D.21749 = (int) D.21748;
      D.21750 = D.21749 + 1;
      D.21751 = (unsigned int) D.21750;
      if (D.21746 > D.21751) goto <D.21744>; else goto <D.21745>;
      <D.21744>:
      D.21752 = ctx->report_error;
      if (D.21752 != 0) goto <D.21753>; else goto <D.21754>;
      <D.21753>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21746 = data[0];
        D.21755 = monoeg_g_strdup_printf ("Invalid EventMap row %d Parent field 0x%08x", i, D.21746);
        vinfo->info.message = D.21755;
        vinfo->exception_type = 3;
        D.21756 = ctx->errors;
        D.21757 = monoeg_g_slist_prepend (D.21756, vinfo);
        ctx->errors = D.21757;
      }
      <D.21754>:
      ctx->valid = 0;
      return;
      <D.21745>:
      D.21760 = data[1];
      if (D.21760 == 0) goto <D.21758>; else goto <D.21761>;
      <D.21761>:
      D.21760 = data[1];
      if (D.21760 <= eventlist) goto <D.21758>; else goto <D.21759>;
      <D.21758>:
      D.21752 = ctx->report_error;
      if (D.21752 != 0) goto <D.21762>; else goto <D.21763>;
      <D.21762>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21760 = data[1];
        D.21764 = monoeg_g_strdup_printf ("Invalid EventMap row %d EventList field %d", i, D.21760);
        vinfo->info.message = D.21764;
        vinfo->exception_type = 3;
        D.21756 = ctx->errors;
        D.21765 = monoeg_g_slist_prepend (D.21756, vinfo);
        ctx->errors = D.21765;
      }
      <D.21763>:
      ctx->valid = 0;
      return;
      <D.21759>:
      eventlist = data[1];
      i = i + 1;
      <D.18761>:
      D.21766 = table->rows;
      D.21767 = (int) D.21766;
      if (D.21767 > i) goto <D.18760>; else goto <D.18762>;
      <D.18762>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_event_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21771;
  unsigned int D.21772;
  unsigned int D.21773;
  int D.21776;
  gchar * D.21779;
  struct GSList * D.21780;
  struct GSList * D.21781;
  unsigned int D.21782;
  int D.21783;
  gchar * D.21788;
  struct GSList * D.21789;
  unsigned int D.21790;
  int D.21791;
  gchar * D.21796;
  struct GSList * D.21797;
  <unnamed-unsigned:24> D.21798;
  int D.21799;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.21771 = ctx->image;
      table = &D.21771->tables[20];
      i = 0;
      goto <D.18773>;
      <D.18772>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.21772 = data[0];
      D.21773 = D.21772 & 4294965759;
      if (D.21773 != 0) goto <D.21774>; else goto <D.21775>;
      <D.21774>:
      D.21776 = ctx->report_error;
      if (D.21776 != 0) goto <D.21777>; else goto <D.21778>;
      <D.21777>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21772 = data[0];
        D.21779 = monoeg_g_strdup_printf ("Invalid Event row %d EventFlags field %08x", i, D.21772);
        vinfo->info.message = D.21779;
        vinfo->exception_type = 3;
        D.21780 = ctx->errors;
        D.21781 = monoeg_g_slist_prepend (D.21780, vinfo);
        ctx->errors = D.21781;
      }
      <D.21778>:
      ctx->valid = 0;
      return;
      <D.21775>:
      D.21782 = data[1];
      D.21783 = is_valid_non_empty_string (ctx, D.21782);
      if (D.21783 == 0) goto <D.21784>; else goto <D.21785>;
      <D.21784>:
      D.21776 = ctx->report_error;
      if (D.21776 != 0) goto <D.21786>; else goto <D.21787>;
      <D.21786>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21782 = data[1];
        D.21788 = monoeg_g_strdup_printf ("Invalid Event row %d Name field %08x", i, D.21782);
        vinfo->info.message = D.21788;
        vinfo->exception_type = 3;
        D.21780 = ctx->errors;
        D.21789 = monoeg_g_slist_prepend (D.21780, vinfo);
        ctx->errors = D.21789;
      }
      <D.21787>:
      ctx->valid = 0;
      return;
      <D.21785>:
      D.21790 = data[2];
      D.21791 = is_valid_coded_index (ctx, 0, D.21790);
      if (D.21791 == 0) goto <D.21792>; else goto <D.21793>;
      <D.21792>:
      D.21776 = ctx->report_error;
      if (D.21776 != 0) goto <D.21794>; else goto <D.21795>;
      <D.21794>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21790 = data[2];
        D.21796 = monoeg_g_strdup_printf ("Invalid Event row %d EventType field %08x", i, D.21790);
        vinfo->info.message = D.21796;
        vinfo->exception_type = 3;
        D.21780 = ctx->errors;
        D.21797 = monoeg_g_slist_prepend (D.21780, vinfo);
        ctx->errors = D.21797;
      }
      <D.21795>:
      ctx->valid = 0;
      return;
      <D.21793>:
      i = i + 1;
      <D.18773>:
      D.21798 = table->rows;
      D.21799 = (int) D.21798;
      if (D.21799 > i) goto <D.18772>; else goto <D.18774>;
      <D.18774>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_propertymap_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21803;
  unsigned int D.21806;
  <unnamed-unsigned:24> D.21808;
  int D.21809;
  int D.21810;
  unsigned int D.21811;
  int D.21812;
  gchar * D.21815;
  struct GSList * D.21816;
  struct GSList * D.21817;
  unsigned int D.21820;
  gchar * D.21824;
  struct GSList * D.21825;
  <unnamed-unsigned:24> D.21826;
  int D.21827;
  struct MonoTableInfo * table;
  guint32 data[2];
  guint32 propertylist;
  int i;

  try
    {
      D.21803 = ctx->image;
      table = &D.21803->tables[21];
      propertylist = 0;
      i = 0;
      goto <D.18809>;
      <D.18808>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.21806 = data[0];
      if (D.21806 == 0) goto <D.21804>; else goto <D.21807>;
      <D.21807>:
      D.21806 = data[0];
      D.21803 = ctx->image;
      D.21808 = D.21803->tables[2].rows;
      D.21809 = (int) D.21808;
      D.21810 = D.21809 + 1;
      D.21811 = (unsigned int) D.21810;
      if (D.21806 > D.21811) goto <D.21804>; else goto <D.21805>;
      <D.21804>:
      D.21812 = ctx->report_error;
      if (D.21812 != 0) goto <D.21813>; else goto <D.21814>;
      <D.21813>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21806 = data[0];
        D.21815 = monoeg_g_strdup_printf ("Invalid PropertyMap row %d Parent field 0x%08x", i, D.21806);
        vinfo->info.message = D.21815;
        vinfo->exception_type = 3;
        D.21816 = ctx->errors;
        D.21817 = monoeg_g_slist_prepend (D.21816, vinfo);
        ctx->errors = D.21817;
      }
      <D.21814>:
      ctx->valid = 0;
      return;
      <D.21805>:
      D.21820 = data[1];
      if (D.21820 == 0) goto <D.21818>; else goto <D.21821>;
      <D.21821>:
      D.21820 = data[1];
      if (D.21820 <= propertylist) goto <D.21818>; else goto <D.21819>;
      <D.21818>:
      D.21812 = ctx->report_error;
      if (D.21812 != 0) goto <D.21822>; else goto <D.21823>;
      <D.21822>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21820 = data[1];
        D.21824 = monoeg_g_strdup_printf ("Invalid PropertyMap row %d PropertyList field %d", i, D.21820);
        vinfo->info.message = D.21824;
        vinfo->exception_type = 3;
        D.21816 = ctx->errors;
        D.21825 = monoeg_g_slist_prepend (D.21816, vinfo);
        ctx->errors = D.21825;
      }
      <D.21823>:
      ctx->valid = 0;
      return;
      <D.21819>:
      propertylist = data[1];
      i = i + 1;
      <D.18809>:
      D.21826 = table->rows;
      D.21827 = (int) D.21826;
      if (D.21827 > i) goto <D.18808>; else goto <D.18810>;
      <D.18810>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_property_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21831;
  unsigned int D.21832;
  unsigned int D.21833;
  int D.21836;
  gchar * D.21839;
  struct GSList * D.21840;
  struct GSList * D.21841;
  unsigned int D.21842;
  int D.21843;
  gchar * D.21848;
  struct GSList * D.21849;
  unsigned int D.21850;
  int D.21851;
  gchar * D.21856;
  struct GSList * D.21857;
  unsigned int D.21858;
  unsigned int i.51;
  unsigned int D.21862;
  int D.21863;
  gchar * D.21868;
  struct GSList * D.21869;
  <unnamed-unsigned:24> D.21870;
  int D.21871;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.21831 = ctx->image;
      table = &D.21831->tables[23];
      i = 0;
      goto <D.18822>;
      <D.18821>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.21832 = data[0];
      D.21833 = D.21832 & 4294961663;
      if (D.21833 != 0) goto <D.21834>; else goto <D.21835>;
      <D.21834>:
      D.21836 = ctx->report_error;
      if (D.21836 != 0) goto <D.21837>; else goto <D.21838>;
      <D.21837>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21832 = data[0];
        D.21839 = monoeg_g_strdup_printf ("Invalid Property row %d PropertyFlags field %08x", i, D.21832);
        vinfo->info.message = D.21839;
        vinfo->exception_type = 3;
        D.21840 = ctx->errors;
        D.21841 = monoeg_g_slist_prepend (D.21840, vinfo);
        ctx->errors = D.21841;
      }
      <D.21838>:
      ctx->valid = 0;
      return;
      <D.21835>:
      D.21842 = data[1];
      D.21843 = is_valid_non_empty_string (ctx, D.21842);
      if (D.21843 == 0) goto <D.21844>; else goto <D.21845>;
      <D.21844>:
      D.21836 = ctx->report_error;
      if (D.21836 != 0) goto <D.21846>; else goto <D.21847>;
      <D.21846>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21842 = data[1];
        D.21848 = monoeg_g_strdup_printf ("Invalid Property row %d Name field %08x", i, D.21842);
        vinfo->info.message = D.21848;
        vinfo->exception_type = 3;
        D.21840 = ctx->errors;
        D.21849 = monoeg_g_slist_prepend (D.21840, vinfo);
        ctx->errors = D.21849;
      }
      <D.21847>:
      ctx->valid = 0;
      return;
      <D.21845>:
      D.21850 = data[2];
      D.21851 = is_valid_property_sig_blob (ctx, D.21850);
      if (D.21851 == 0) goto <D.21852>; else goto <D.21853>;
      <D.21852>:
      D.21836 = ctx->report_error;
      if (D.21836 != 0) goto <D.21854>; else goto <D.21855>;
      <D.21854>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21850 = data[2];
        D.21856 = monoeg_g_strdup_printf ("Invalid Property row %d Type field %08x", i, D.21850);
        vinfo->info.message = D.21856;
        vinfo->exception_type = 3;
        D.21840 = ctx->errors;
        D.21857 = monoeg_g_slist_prepend (D.21840, vinfo);
        ctx->errors = D.21857;
      }
      <D.21855>:
      ctx->valid = 0;
      return;
      <D.21853>:
      D.21832 = data[0];
      D.21858 = D.21832 & 4096;
      if (D.21858 != 0) goto <D.21859>; else goto <D.21860>;
      <D.21859>:
      i.51 = (unsigned int) i;
      D.21862 = make_coded_token (5, 23, i.51);
      D.21863 = search_sorted_table (ctx, 11, 2, D.21862);
      if (D.21863 == -1) goto <D.21864>; else goto <D.21865>;
      <D.21864>:
      D.21836 = ctx->report_error;
      if (D.21836 != 0) goto <D.21866>; else goto <D.21867>;
      <D.21866>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21868 = 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.21868;
        vinfo->exception_type = 3;
        D.21840 = ctx->errors;
        D.21869 = monoeg_g_slist_prepend (D.21840, vinfo);
        ctx->errors = D.21869;
      }
      <D.21867>:
      ctx->valid = 0;
      return;
      <D.21865>:
      <D.21860>:
      i = i + 1;
      <D.18822>:
      D.21870 = table->rows;
      D.21871 = (int) D.21870;
      if (D.21871 > i) goto <D.18821>; else goto <D.18823>;
      <D.18823>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_property_sig_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.21875;
  int D.21878;
  gchar * D.21881;
  struct GSList * D.21882;
  struct GSList * D.21883;
  gboolean D.21884;
  const char * ptr.52;
  unsigned int size.53;
  guint32 size;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      ptr = 0B;
      D.21875 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.21875 == 0) goto <D.21876>; else goto <D.21877>;
      <D.21876>:
      D.21878 = ctx->report_error;
      if (D.21878 != 0) goto <D.21879>; else goto <D.21880>;
      <D.21879>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21881 = monoeg_strdup ("PropertySig: Could not decode signature header");
        vinfo->info.message = D.21881;
        vinfo->exception_type = 3;
        D.21882 = ctx->errors;
        D.21883 = monoeg_g_slist_prepend (D.21882, vinfo);
        ctx->errors = D.21883;
      }
      <D.21880>:
      ctx->valid = 0;
      D.21884 = 0;
      return D.21884;
      <D.21877>:
      ptr.52 = ptr;
      size.53 = size;
      end = ptr.52 + size.53;
      D.21884 = parse_property_signature (ctx, &ptr, end);
      return D.21884;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


decode_signature_header (struct VerifyContext * ctx, guint32 offset, guint32 * size, const char * * first_byte)
{
  struct MonoImage * D.21889;
  unsigned int D.21890;
  gboolean D.21893;
  unsigned int D.21894;
  const char * D.21895;
  const char * D.21896;
  int D.21897;
  unsigned int enc_size.54;
  unsigned int D.21901;
  unsigned int value.55;
  unsigned int D.21907;
  unsigned int D.21909;
  struct MonoStreamHeader blob;
  guint32 value;
  guint32 enc_size;

  try
    {
      D.21889 = ctx->image;
      blob = D.21889->heap_blob;
      D.21890 = blob.size;
      if (D.21890 <= offset) goto <D.21891>; else goto <D.21892>;
      <D.21891>:
      D.21893 = 0;
      return D.21893;
      <D.21892>:
      D.21890 = blob.size;
      D.21894 = D.21890 - offset;
      D.21895 = blob.data;
      D.21896 = D.21895 + offset;
      D.21897 = decode_value (D.21896, D.21894, &value, &enc_size);
      if (D.21897 == 0) goto <D.21898>; else goto <D.21899>;
      <D.21898>:
      D.21893 = 0;
      return D.21893;
      <D.21899>:
      enc_size.54 = enc_size;
      D.21901 = ~enc_size.54;
      if (D.21901 < offset) goto <D.21902>; else goto <D.21903>;
      <D.21902>:
      D.21893 = 0;
      return D.21893;
      <D.21903>:
      enc_size.54 = enc_size;
      offset = offset + enc_size.54;
      value.55 = value;
      D.21907 = offset + value.55;
      D.21890 = blob.size;
      if (D.21907 > D.21890) goto <D.21904>; else goto <D.21908>;
      <D.21908>:
      value.55 = value;
      D.21909 = ~value.55;
      if (D.21909 < offset) goto <D.21904>; else goto <D.21905>;
      <D.21904>:
      D.21893 = 0;
      return D.21893;
      <D.21905>:
      value.55 = value;
      *size = value.55;
      D.21895 = blob.data;
      D.21896 = D.21895 + offset;
      *first_byte = D.21896;
      D.21893 = 1;
      return D.21893;
    }
  finally
    {
      blob = {CLOBBER};
      value = {CLOBBER};
      enc_size = {CLOBBER};
    }
}


parse_property_signature (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.56;
  int D.21913;
  int D.21916;
  gchar * D.21919;
  struct GSList * D.21920;
  struct GSList * D.21921;
  gboolean D.21922;
  unsigned int sig.57;
  _Bool D.21924;
  _Bool D.21925;
  _Bool D.21926;
  unsigned int sig.58;
  gchar * D.21932;
  struct GSList * D.21933;
  int D.21934;
  gchar * D.21939;
  struct GSList * D.21940;
  int D.21941;
  int D.21944;
  gchar * D.21949;
  struct GSList * D.21950;
  int D.21951;
  gchar * D.21956;
  struct GSList * D.21957;
  int D.21958;
  gchar * D.21963;
  struct GSList * D.21964;
  unsigned int param_count.59;
  const char * ptr.60;
  unsigned int sig;
  unsigned int param_count;
  unsigned int i;
  const char * ptr;

  try
    {
      sig = 0;
      param_count = 0;
      ptr.56 = *_ptr;
      ptr = ptr.56;
      D.21913 = safe_read (&ptr, end, &sig, 1);
      if (D.21913 == 0) goto <D.21914>; else goto <D.21915>;
      <D.21914>:
      D.21916 = ctx->report_error;
      if (D.21916 != 0) goto <D.21917>; else goto <D.21918>;
      <D.21917>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21919 = monoeg_strdup ("PropertySig: Not enough room for signature");
        vinfo->info.message = D.21919;
        vinfo->exception_type = 3;
        D.21920 = ctx->errors;
        D.21921 = monoeg_g_slist_prepend (D.21920, vinfo);
        ctx->errors = D.21921;
      }
      <D.21918>:
      ctx->valid = 0;
      D.21922 = 0;
      return D.21922;
      <D.21915>:
      sig.57 = sig;
      D.21924 = sig.57 != 8;
      D.21925 = sig.57 != 40;
      D.21926 = D.21924 & D.21925;
      if (D.21926 != 0) goto <D.21927>; else goto <D.21928>;
      <D.21927>:
      D.21916 = ctx->report_error;
      if (D.21916 != 0) goto <D.21929>; else goto <D.21930>;
      <D.21929>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        sig.58 = sig;
        D.21932 = monoeg_g_strdup_printf ("PropertySig: Signature is not 0x28 or 0x08: %x", sig.58);
        vinfo->info.message = D.21932;
        vinfo->exception_type = 3;
        D.21920 = ctx->errors;
        D.21933 = monoeg_g_slist_prepend (D.21920, vinfo);
        ctx->errors = D.21933;
      }
      <D.21930>:
      ctx->valid = 0;
      D.21922 = 0;
      return D.21922;
      <D.21928>:
      D.21934 = safe_read_compressed_int (&ptr, end, &param_count);
      if (D.21934 == 0) goto <D.21935>; else goto <D.21936>;
      <D.21935>:
      D.21916 = ctx->report_error;
      if (D.21916 != 0) goto <D.21937>; else goto <D.21938>;
      <D.21937>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21939 = monoeg_strdup ("PropertySig: Not enough room for the param count");
        vinfo->info.message = D.21939;
        vinfo->exception_type = 3;
        D.21920 = ctx->errors;
        D.21940 = monoeg_g_slist_prepend (D.21920, vinfo);
        ctx->errors = D.21940;
      }
      <D.21938>:
      ctx->valid = 0;
      D.21922 = 0;
      return D.21922;
      <D.21936>:
      D.21941 = parse_custom_mods (ctx, &ptr, end);
      if (D.21941 == 0) goto <D.21942>; else goto <D.21943>;
      <D.21942>:
      D.21922 = 0;
      return D.21922;
      <D.21943>:
      D.21944 = parse_type (ctx, &ptr, end);
      if (D.21944 == 0) goto <D.21945>; else goto <D.21946>;
      <D.21945>:
      D.21916 = ctx->report_error;
      if (D.21916 != 0) goto <D.21947>; else goto <D.21948>;
      <D.21947>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21949 = monoeg_strdup ("PropertySig: Could not parse property type");
        vinfo->info.message = D.21949;
        vinfo->exception_type = 3;
        D.21920 = ctx->errors;
        D.21950 = monoeg_g_slist_prepend (D.21920, vinfo);
        ctx->errors = D.21950;
      }
      <D.21948>:
      ctx->valid = 0;
      D.21922 = 0;
      return D.21922;
      <D.21946>:
      i = 0;
      goto <D.18005>;
      <D.18004>:
      D.21951 = parse_custom_mods (ctx, &ptr, end);
      if (D.21951 == 0) goto <D.21952>; else goto <D.21953>;
      <D.21952>:
      D.21916 = ctx->report_error;
      if (D.21916 != 0) goto <D.21954>; else goto <D.21955>;
      <D.21954>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21956 = monoeg_strdup ("Type: Failed to parse pointer custom attr");
        vinfo->info.message = D.21956;
        vinfo->exception_type = 3;
        D.21920 = ctx->errors;
        D.21957 = monoeg_g_slist_prepend (D.21920, vinfo);
        ctx->errors = D.21957;
      }
      <D.21955>:
      ctx->valid = 0;
      D.21922 = 0;
      return D.21922;
      <D.21953>:
      D.21958 = parse_type (ctx, &ptr, end);
      if (D.21958 == 0) goto <D.21959>; else goto <D.21960>;
      <D.21959>:
      D.21916 = ctx->report_error;
      if (D.21916 != 0) goto <D.21961>; else goto <D.21962>;
      <D.21961>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21963 = monoeg_g_strdup_printf ("PropertySig: Error parsing arg %d", i);
        vinfo->info.message = D.21963;
        vinfo->exception_type = 3;
        D.21920 = ctx->errors;
        D.21964 = monoeg_g_slist_prepend (D.21920, vinfo);
        ctx->errors = D.21964;
      }
      <D.21962>:
      ctx->valid = 0;
      D.21922 = 0;
      return D.21922;
      <D.21960>:
      i = i + 1;
      <D.18005>:
      param_count.59 = param_count;
      if (i < param_count.59) goto <D.18004>; else goto <D.18006>;
      <D.18006>:
      ptr.60 = ptr;
      *_ptr = ptr.60;
      D.21922 = 1;
      return D.21922;
    }
  finally
    {
      sig = {CLOBBER};
      param_count = {CLOBBER};
      ptr = {CLOBBER};
    }
}


safe_read (const char * * _ptr, const char * limit, unsigned int * dest, int size)
{
  sizetype size.61;
  const char * D.21970;
  gboolean D.21973;
  unsigned char D.21974;
  unsigned int D.21975;
  short unsigned int D.21976;
  unsigned int D.21977;
  unsigned int D.21978;
  const char * ptr;

  ptr = *_ptr;
  size.61 = (sizetype) size;
  D.21970 = ptr + size.61;
  if (D.21970 > limit) goto <D.21971>; else goto <D.21972>;
  <D.21971>:
  D.21973 = 0;
  return D.21973;
  <D.21972>:
  switch (size) <default: <D.21979>, case 1: <D.17830>, case 2: <D.17832>, case 4: <D.17833>>
  <D.17830>:
  D.21974 = MEM[(guint8 *)ptr];
  D.21975 = (unsigned int) D.21974;
  *dest = D.21975;
  ptr = ptr + 1;
  goto <D.17831>;
  <D.17832>:
  D.21976 = MEM[(const guint16 *)ptr];
  D.21977 = (unsigned int) D.21976;
  *dest = D.21977;
  ptr = ptr + 2;
  goto <D.17831>;
  <D.17833>:
  D.21978 = MEM[(const guint32 *)ptr];
  *dest = D.21978;
  ptr = ptr + 4;
  goto <D.17831>;
  <D.21979>:
  <D.17831>:
  *_ptr = ptr;
  D.21973 = 1;
  return D.21973;
}


safe_read_compressed_int (const char * * _ptr, const char * limit, unsigned int * dest)
{
  int limit.62;
  int ptr.63;
  int D.21983;
  unsigned int D.21984;
  unsigned int size.64;
  const char * D.21986;
  gboolean D.21987;
  unsigned int size;
  const char * ptr;
  gboolean res;

  try
    {
      size = 0;
      ptr = *_ptr;
      limit.62 = (int) limit;
      ptr.63 = (int) ptr;
      D.21983 = limit.62 - ptr.63;
      D.21984 = (unsigned int) D.21983;
      res = decode_value (ptr, D.21984, dest, &size);
      size.64 = size;
      D.21986 = ptr + size.64;
      *_ptr = D.21986;
      D.21987 = res;
      return D.21987;
    }
  finally
    {
      size = {CLOBBER};
    }
}


parse_custom_mods (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.65;
  int D.21991;
  int D.21994;
  gchar * D.21997;
  struct GSList * D.21998;
  struct GSList * D.21999;
  gboolean D.22000;
  unsigned int type.66;
  unsigned int D.22002;
  const char * ptr.67;
  const char * ptr.68;
  int D.22007;
  gchar * D.22012;
  struct GSList * D.22013;
  unsigned int token.69;
  int D.22017;
  unsigned int D.22019;
  gchar * D.22022;
  struct GSList * D.22023;
  const char * ptr;
  unsigned int type;
  unsigned int token;

  try
    {
      ptr.65 = *_ptr;
      ptr = ptr.65;
      type = 0;
      token = 0;
      <D.17864>:
      D.21991 = safe_read (&ptr, end, &type, 1);
      if (D.21991 == 0) goto <D.21992>; else goto <D.21993>;
      <D.21992>:
      D.21994 = ctx->report_error;
      if (D.21994 != 0) goto <D.21995>; else goto <D.21996>;
      <D.21995>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21997 = monoeg_strdup ("CustomMod: Not enough room for the type");
        vinfo->info.message = D.21997;
        vinfo->exception_type = 3;
        D.21998 = ctx->errors;
        D.21999 = monoeg_g_slist_prepend (D.21998, vinfo);
        ctx->errors = D.21999;
      }
      <D.21996>:
      ctx->valid = 0;
      D.22000 = 0;
      return D.22000;
      <D.21993>:
      type.66 = type;
      D.22002 = type.66 + 4294967265;
      if (D.22002 > 1) goto <D.22003>; else goto <D.22004>;
      <D.22003>:
      ptr.67 = ptr;
      ptr.68 = ptr.67 + 4294967295;
      ptr = ptr.68;
      goto <D.17861>;
      <D.22004>:
      D.22007 = safe_read_compressed_int (&ptr, end, &token);
      if (D.22007 == 0) goto <D.22008>; else goto <D.22009>;
      <D.22008>:
      D.21994 = ctx->report_error;
      if (D.21994 != 0) goto <D.22010>; else goto <D.22011>;
      <D.22010>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22012 = monoeg_strdup ("CustomMod: Not enough room for the token");
        vinfo->info.message = D.22012;
        vinfo->exception_type = 3;
        D.21998 = ctx->errors;
        D.22013 = monoeg_g_slist_prepend (D.21998, vinfo);
        ctx->errors = D.22013;
      }
      <D.22011>:
      ctx->valid = 0;
      D.22000 = 0;
      return D.22000;
      <D.22009>:
      token.69 = token;
      D.22017 = is_valid_coded_index (ctx, 0, token.69);
      if (D.22017 == 0) goto <D.22014>; else goto <D.22018>;
      <D.22018>:
      token.69 = token;
      D.22019 = get_coded_index_token (0, token.69);
      if (D.22019 == 0) goto <D.22014>; else goto <D.22015>;
      <D.22014>:
      D.21994 = ctx->report_error;
      if (D.21994 != 0) goto <D.22020>; else goto <D.22021>;
      <D.22020>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        token.69 = token;
        D.22022 = monoeg_g_strdup_printf ("CustomMod: invalid TypeDefOrRef token %x", token.69);
        vinfo->info.message = D.22022;
        vinfo->exception_type = 3;
        D.21998 = ctx->errors;
        D.22023 = monoeg_g_slist_prepend (D.21998, vinfo);
        ctx->errors = D.22023;
      }
      <D.22021>:
      ctx->valid = 0;
      D.22000 = 0;
      return D.22000;
      <D.22015>:
      goto <D.17864>;
      <D.17861>:
      ptr.67 = ptr;
      *_ptr = ptr.67;
      D.22000 = 1;
      return D.22000;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
      token = {CLOBBER};
    }
}


parse_type (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.70;
  int D.22027;
  int D.22030;
  gchar * D.22033;
  struct GSList * D.22034;
  struct GSList * D.22035;
  gboolean D.22036;
  unsigned int type.71;
  unsigned int D.22038;
  _Bool D.22039;
  unsigned int D.22040;
  _Bool D.22041;
  _Bool D.22042;
  unsigned int type.72;
  unsigned int D.22046;
  unsigned int D.22049;
  gchar * D.22054;
  struct GSList * D.22055;
  int D.22056;
  gchar * D.22061;
  struct GSList * D.22062;
  int D.22063;
  gchar * D.22068;
  struct GSList * D.22069;
  const char * ptr.73;
  const char * ptr.74;
  int D.22074;
  gchar * D.22079;
  struct GSList * D.22080;
  int D.22081;
  gchar * D.22086;
  struct GSList * D.22087;
  unsigned int token.75;
  int D.22091;
  unsigned int D.22093;
  gchar * D.22096;
  struct GSList * D.22097;
  unsigned int D.22098;
  gchar * D.22103;
  struct GSList * D.22104;
  unsigned int D.22105;
  unsigned int D.22108;
  unsigned int D.22109;
  unsigned int D.22112;
  unsigned int D.22113;
  gchar * D.22118;
  struct GSList * D.22119;
  int D.22120;
  gchar * D.22125;
  struct GSList * D.22126;
  int D.22127;
  gchar * D.22132;
  struct GSList * D.22133;
  int D.22134;
  gchar * D.22139;
  struct GSList * D.22140;
  int D.22141;
  gchar * D.22146;
  struct GSList * D.22147;
  int D.22148;
  gchar * D.22153;
  struct GSList * D.22154;
  int D.22155;
  gchar * D.22160;
  struct GSList * D.22161;
  int D.22162;
  gchar * D.22167;
  struct GSList * D.22168;
  const char * ptr;
  unsigned int type;
  unsigned int token;

  try
    {
      ptr.70 = *_ptr;
      ptr = ptr.70;
      token = 0;
      D.22027 = safe_read (&ptr, end, &type, 1);
      if (D.22027 == 0) goto <D.22028>; else goto <D.22029>;
      <D.22028>:
      D.22030 = ctx->report_error;
      if (D.22030 != 0) goto <D.22031>; else goto <D.22032>;
      <D.22031>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22033 = monoeg_strdup ("Type: Not enough room for the type");
        vinfo->info.message = D.22033;
        vinfo->exception_type = 3;
        D.22034 = ctx->errors;
        D.22035 = monoeg_g_slist_prepend (D.22034, vinfo);
        ctx->errors = D.22035;
      }
      <D.22032>:
      ctx->valid = 0;
      D.22036 = 0;
      return D.22036;
      <D.22029>:
      type.71 = type;
      D.22038 = type.71 + 4294967294;
      D.22039 = D.22038 > 13;
      D.22040 = type.71 + 4294967279;
      D.22041 = D.22040 > 4;
      D.22042 = D.22039 & D.22041;
      if (D.22042 != 0) goto <D.22043>; else goto <D.22044>;
      <D.22043>:
      type.72 = type;
      D.22046 = type.72 + 4294967272;
      if (D.22046 > 1) goto <D.22047>; else goto <D.22048>;
      <D.22047>:
      type.72 = type;
      D.22049 = type.72 + 4294967269;
      if (D.22049 > 3) goto <D.22050>; else goto <D.22051>;
      <D.22050>:
      D.22030 = ctx->report_error;
      if (D.22030 != 0) goto <D.22052>; else goto <D.22053>;
      <D.22052>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        type.72 = type;
        D.22054 = monoeg_g_strdup_printf ("Type: Invalid type kind %x\n", type.72);
        vinfo->info.message = D.22054;
        vinfo->exception_type = 3;
        D.22034 = ctx->errors;
        D.22055 = monoeg_g_slist_prepend (D.22034, vinfo);
        ctx->errors = D.22055;
      }
      <D.22053>:
      ctx->valid = 0;
      D.22036 = 0;
      return D.22036;
      <D.22051>:
      <D.22048>:
      <D.22044>:
      type.72 = type;
      switch (type.72) <default: <D.22169>, case 15: <D.17919>, case 17: <D.17924>, case 18: <D.17925>, case 19: <D.17930>, case 20: <D.17933>, case 21: <D.17936>, case 27: <D.17938>, case 29: <D.17940>, case 30: <D.17931>>
      <D.17919>:
      D.22056 = parse_custom_mods (ctx, &ptr, end);
      if (D.22056 == 0) goto <D.22057>; else goto <D.22058>;
      <D.22057>:
      D.22030 = ctx->report_error;
      if (D.22030 != 0) goto <D.22059>; else goto <D.22060>;
      <D.22059>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22061 = monoeg_strdup ("Type: Failed to parse pointer custom attr");
        vinfo->info.message = D.22061;
        vinfo->exception_type = 3;
        D.22034 = ctx->errors;
        D.22062 = monoeg_g_slist_prepend (D.22034, vinfo);
        ctx->errors = D.22062;
      }
      <D.22060>:
      ctx->valid = 0;
      D.22036 = 0;
      return D.22036;
      <D.22058>:
      D.22063 = safe_read (&ptr, end, &type, 1);
      if (D.22063 == 0) goto <D.22064>; else goto <D.22065>;
      <D.22064>:
      D.22030 = ctx->report_error;
      if (D.22030 != 0) goto <D.22066>; else goto <D.22067>;
      <D.22066>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22068 = monoeg_strdup ("Type: Not enough room to parse the pointer type");
        vinfo->info.message = D.22068;
        vinfo->exception_type = 3;
        D.22034 = ctx->errors;
        D.22069 = monoeg_g_slist_prepend (D.22034, vinfo);
        ctx->errors = D.22069;
      }
      <D.22067>:
      ctx->valid = 0;
      D.22036 = 0;
      return D.22036;
      <D.22065>:
      type.72 = type;
      if (type.72 != 1) goto <D.22070>; else goto <D.22071>;
      <D.22070>:
      ptr.73 = ptr;
      ptr.74 = ptr.73 + 4294967295;
      ptr = ptr.74;
      D.22074 = parse_type (ctx, &ptr, end);
      if (D.22074 == 0) goto <D.22075>; else goto <D.22076>;
      <D.22075>:
      D.22030 = ctx->report_error;
      if (D.22030 != 0) goto <D.22077>; else goto <D.22078>;
      <D.22077>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22079 = monoeg_strdup ("Type: Could not parse pointer type");
        vinfo->info.message = D.22079;
        vinfo->exception_type = 3;
        D.22034 = ctx->errors;
        D.22080 = monoeg_g_slist_prepend (D.22034, vinfo);
        ctx->errors = D.22080;
      }
      <D.22078>:
      ctx->valid = 0;
      D.22036 = 0;
      return D.22036;
      <D.22076>:
      <D.22071>:
      goto <D.17923>;
      <D.17924>:
      <D.17925>:
      D.22081 = safe_read_compressed_int (&ptr, end, &token);
      if (D.22081 == 0) goto <D.22082>; else goto <D.22083>;
      <D.22082>:
      D.22030 = ctx->report_error;
      if (D.22030 != 0) goto <D.22084>; else goto <D.22085>;
      <D.22084>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22086 = monoeg_strdup ("Type: Not enough room for the type token");
        vinfo->info.message = D.22086;
        vinfo->exception_type = 3;
        D.22034 = ctx->errors;
        D.22087 = monoeg_g_slist_prepend (D.22034, vinfo);
        ctx->errors = D.22087;
      }
      <D.22085>:
      ctx->valid = 0;
      D.22036 = 0;
      return D.22036;
      <D.22083>:
      token.75 = token;
      D.22091 = is_valid_coded_index (ctx, 0, token.75);
      if (D.22091 == 0) goto <D.22088>; else goto <D.22092>;
      <D.22092>:
      token.75 = token;
      D.22093 = get_coded_index_token (0, token.75);
      if (D.22093 == 0) goto <D.22088>; else goto <D.22089>;
      <D.22088>:
      D.22030 = ctx->report_error;
      if (D.22030 != 0) goto <D.22094>; else goto <D.22095>;
      <D.22094>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        token.75 = token;
        D.22096 = monoeg_g_strdup_printf ("Type: invalid TypeDefOrRef token %x", token.75);
        vinfo->info.message = D.22096;
        vinfo->exception_type = 3;
        D.22034 = ctx->errors;
        D.22097 = monoeg_g_slist_prepend (D.22034, vinfo);
        ctx->errors = D.22097;
      }
      <D.22095>:
      ctx->valid = 0;
      D.22036 = 0;
      return D.22036;
      <D.22089>:
      token.75 = token;
      D.22098 = get_coded_index_token (0, token.75);
      if (D.22098 == 0) goto <D.22099>; else goto <D.22100>;
      <D.22099>:
      D.22030 = ctx->report_error;
      if (D.22030 != 0) goto <D.22101>; else goto <D.22102>;
      <D.22101>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        token.75 = token;
        D.22103 = monoeg_g_strdup_printf ("Type: zero TypeDefOrRef token %x", token.75);
        vinfo->info.message = D.22103;
        vinfo->exception_type = 3;
        D.22034 = ctx->errors;
        D.22104 = monoeg_g_slist_prepend (D.22034, vinfo);
        ctx->errors = D.22104;
      }
      <D.22102>:
      ctx->valid = 0;
      D.22036 = 0;
      return D.22036;
      <D.22100>:
      D.22105 = ctx->token;
      if (D.22105 != 0) goto <D.22106>; else goto <D.22107>;
      <D.22106>:
      D.22105 = ctx->token;
      D.22108 = D.22105 & 16777215;
      token.75 = token;
      D.22109 = get_coded_index_token (0, token.75);
      if (D.22108 == D.22109) goto <D.22110>; else goto <D.22111>;
      <D.22110>:
      D.22105 = ctx->token;
      D.22112 = D.22105 >> 24;
      token.75 = token;
      D.22113 = get_coded_index_table (0, token.75);
      if (D.22112 == D.22113) goto <D.22114>; else goto <D.22115>;
      <D.22114>:
      D.22030 = ctx->report_error;
      if (D.22030 != 0) goto <D.22116>; else goto <D.22117>;
      <D.22116>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22105 = ctx->token;
        D.22118 = monoeg_g_strdup_printf ("Type: Recursive type specification (%x). A type signature can\'t reference itself", D.22105);
        vinfo->info.message = D.22118;
        vinfo->exception_type = 3;
        D.22034 = ctx->errors;
        D.22119 = monoeg_g_slist_prepend (D.22034, vinfo);
        ctx->errors = D.22119;
      }
      <D.22117>:
      ctx->valid = 0;
      D.22036 = 0;
      return D.22036;
      <D.22115>:
      <D.22111>:
      <D.22107>:
      goto <D.17923>;
      <D.17930>:
      <D.17931>:
      D.22120 = safe_read_compressed_int (&ptr, end, &token);
      if (D.22120 == 0) goto <D.22121>; else goto <D.22122>;
      <D.22121>:
      D.22030 = ctx->report_error;
      if (D.22030 != 0) goto <D.22123>; else goto <D.22124>;
      <D.22123>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22125 = monoeg_strdup ("Type: Not enough room for to decode generic argument number");
        vinfo->info.message = D.22125;
        vinfo->exception_type = 3;
        D.22034 = ctx->errors;
        D.22126 = monoeg_g_slist_prepend (D.22034, vinfo);
        ctx->errors = D.22126;
      }
      <D.22124>:
      ctx->valid = 0;
      D.22036 = 0;
      return D.22036;
      <D.22122>:
      goto <D.17923>;
      <D.17933>:
      D.22127 = parse_type (ctx, &ptr, end);
      if (D.22127 == 0) goto <D.22128>; else goto <D.22129>;
      <D.22128>:
      D.22030 = ctx->report_error;
      if (D.22030 != 0) goto <D.22130>; else goto <D.22131>;
      <D.22130>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22132 = monoeg_strdup ("Type: Could not parse array type");
        vinfo->info.message = D.22132;
        vinfo->exception_type = 3;
        D.22034 = ctx->errors;
        D.22133 = monoeg_g_slist_prepend (D.22034, vinfo);
        ctx->errors = D.22133;
      }
      <D.22131>:
      ctx->valid = 0;
      D.22036 = 0;
      return D.22036;
      <D.22129>:
      D.22134 = parse_array_shape (ctx, &ptr, end);
      if (D.22134 == 0) goto <D.22135>; else goto <D.22136>;
      <D.22135>:
      D.22030 = ctx->report_error;
      if (D.22030 != 0) goto <D.22137>; else goto <D.22138>;
      <D.22137>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22139 = monoeg_strdup ("Type: Could not parse array shape");
        vinfo->info.message = D.22139;
        vinfo->exception_type = 3;
        D.22034 = ctx->errors;
        D.22140 = monoeg_g_slist_prepend (D.22034, vinfo);
        ctx->errors = D.22140;
      }
      <D.22138>:
      ctx->valid = 0;
      D.22036 = 0;
      return D.22036;
      <D.22136>:
      goto <D.17923>;
      <D.17936>:
      D.22141 = parse_generic_inst (ctx, &ptr, end);
      if (D.22141 == 0) goto <D.22142>; else goto <D.22143>;
      <D.22142>:
      D.22030 = ctx->report_error;
      if (D.22030 != 0) goto <D.22144>; else goto <D.22145>;
      <D.22144>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22146 = monoeg_strdup ("Type: Could not parse generic inst");
        vinfo->info.message = D.22146;
        vinfo->exception_type = 3;
        D.22034 = ctx->errors;
        D.22147 = monoeg_g_slist_prepend (D.22034, vinfo);
        ctx->errors = D.22147;
      }
      <D.22145>:
      ctx->valid = 0;
      D.22036 = 0;
      return D.22036;
      <D.22143>:
      goto <D.17923>;
      <D.17938>:
      D.22148 = parse_method_signature (ctx, &ptr, end, 1, 1);
      if (D.22148 == 0) goto <D.22149>; else goto <D.22150>;
      <D.22149>:
      D.22030 = ctx->report_error;
      if (D.22030 != 0) goto <D.22151>; else goto <D.22152>;
      <D.22151>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22153 = monoeg_strdup ("Type: Could not parse method pointer signature");
        vinfo->info.message = D.22153;
        vinfo->exception_type = 3;
        D.22034 = ctx->errors;
        D.22154 = monoeg_g_slist_prepend (D.22034, vinfo);
        ctx->errors = D.22154;
      }
      <D.22152>:
      ctx->valid = 0;
      D.22036 = 0;
      return D.22036;
      <D.22150>:
      goto <D.17923>;
      <D.17940>:
      D.22155 = parse_custom_mods (ctx, &ptr, end);
      if (D.22155 == 0) goto <D.22156>; else goto <D.22157>;
      <D.22156>:
      D.22030 = ctx->report_error;
      if (D.22030 != 0) goto <D.22158>; else goto <D.22159>;
      <D.22158>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22160 = monoeg_strdup ("Type: Failed to parse array element custom attr");
        vinfo->info.message = D.22160;
        vinfo->exception_type = 3;
        D.22034 = ctx->errors;
        D.22161 = monoeg_g_slist_prepend (D.22034, vinfo);
        ctx->errors = D.22161;
      }
      <D.22159>:
      ctx->valid = 0;
      D.22036 = 0;
      return D.22036;
      <D.22157>:
      D.22162 = parse_type (ctx, &ptr, end);
      if (D.22162 == 0) goto <D.22163>; else goto <D.22164>;
      <D.22163>:
      D.22030 = ctx->report_error;
      if (D.22030 != 0) goto <D.22165>; else goto <D.22166>;
      <D.22165>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22167 = monoeg_strdup ("Type: Could not parse array type");
        vinfo->info.message = D.22167;
        vinfo->exception_type = 3;
        D.22034 = ctx->errors;
        D.22168 = monoeg_g_slist_prepend (D.22034, vinfo);
        ctx->errors = D.22168;
      }
      <D.22166>:
      ctx->valid = 0;
      D.22036 = 0;
      return D.22036;
      <D.22164>:
      goto <D.17923>;
      <D.22169>:
      <D.17923>:
      ptr.73 = ptr;
      *_ptr = ptr.73;
      D.22036 = 1;
      return D.22036;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
      token = {CLOBBER};
    }
}


get_coded_index_table (int kind, guint32 coded_token)
{
  unsigned char D.22172;
  int bits.76;
  int D.22174;
  int D.22175;
  unsigned int D.22176;
  guint32 D.22177;
  unsigned int kind.77;
  unsigned int D.22179;
  unsigned char D.22180;
  guint32 idx;
  guint32 bits;

  D.22172 = coded_index_desc[kind];
  bits = (guint32) D.22172;
  kind = kind + 2;
  bits.76 = (int) bits;
  D.22174 = 1 << bits.76;
  D.22175 = D.22174 + -1;
  D.22176 = (unsigned int) D.22175;
  idx = D.22176 & coded_token;
  kind.77 = (unsigned int) kind;
  D.22179 = kind.77 + idx;
  D.22180 = coded_index_desc[D.22179];
  D.22177 = (guint32) D.22180;
  return D.22177;
}


parse_array_shape (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.78;
  int D.22183;
  int D.22186;
  gchar * D.22189;
  struct GSList * D.22190;
  struct GSList * D.22191;
  gboolean D.22192;
  unsigned int val.79;
  gchar * D.22198;
  struct GSList * D.22199;
  int D.22200;
  gchar * D.22205;
  struct GSList * D.22206;
  int D.22207;
  unsigned int D.22212;
  gchar * D.22213;
  struct GSList * D.22214;
  unsigned int size.80;
  int D.22216;
  gchar * D.22221;
  struct GSList * D.22222;
  int D.22223;
  gchar * D.22228;
  struct GSList * D.22229;
  const char * ptr.81;
  const char * ptr;
  unsigned int val;
  unsigned int size;
  unsigned int num;
  unsigned int i;

  try
    {
      ptr.78 = *_ptr;
      ptr = ptr.78;
      val = 0;
      D.22183 = safe_read (&ptr, end, &val, 1);
      if (D.22183 == 0) goto <D.22184>; else goto <D.22185>;
      <D.22184>:
      D.22186 = ctx->report_error;
      if (D.22186 != 0) goto <D.22187>; else goto <D.22188>;
      <D.22187>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22189 = monoeg_strdup ("ArrayShape: Not enough room for Rank");
        vinfo->info.message = D.22189;
        vinfo->exception_type = 3;
        D.22190 = ctx->errors;
        D.22191 = monoeg_g_slist_prepend (D.22190, vinfo);
        ctx->errors = D.22191;
      }
      <D.22188>:
      ctx->valid = 0;
      D.22192 = 0;
      return D.22192;
      <D.22185>:
      val.79 = val;
      if (val.79 == 0) goto <D.22194>; else goto <D.22195>;
      <D.22194>:
      D.22186 = ctx->report_error;
      if (D.22186 != 0) goto <D.22196>; else goto <D.22197>;
      <D.22196>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22198 = monoeg_strdup ("ArrayShape: Invalid shape with zero Rank");
        vinfo->info.message = D.22198;
        vinfo->exception_type = 3;
        D.22190 = ctx->errors;
        D.22199 = monoeg_g_slist_prepend (D.22190, vinfo);
        ctx->errors = D.22199;
      }
      <D.22197>:
      ctx->valid = 0;
      D.22192 = 0;
      return D.22192;
      <D.22195>:
      D.22200 = safe_read_compressed_int (&ptr, end, &size);
      if (D.22200 == 0) goto <D.22201>; else goto <D.22202>;
      <D.22201>:
      D.22186 = ctx->report_error;
      if (D.22186 != 0) goto <D.22203>; else goto <D.22204>;
      <D.22203>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22205 = monoeg_strdup ("ArrayShape: Not enough room for NumSizes");
        vinfo->info.message = D.22205;
        vinfo->exception_type = 3;
        D.22190 = ctx->errors;
        D.22206 = monoeg_g_slist_prepend (D.22190, vinfo);
        ctx->errors = D.22206;
      }
      <D.22204>:
      ctx->valid = 0;
      D.22192 = 0;
      return D.22192;
      <D.22202>:
      i = 0;
      goto <D.17880>;
      <D.17879>:
      D.22207 = safe_read_compressed_int (&ptr, end, &num);
      if (D.22207 == 0) goto <D.22208>; else goto <D.22209>;
      <D.22208>:
      D.22186 = ctx->report_error;
      if (D.22186 != 0) goto <D.22210>; else goto <D.22211>;
      <D.22210>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22212 = i + 1;
        D.22213 = monoeg_g_strdup_printf ("ArrayShape: Not enough room for Size of rank %d", D.22212);
        vinfo->info.message = D.22213;
        vinfo->exception_type = 3;
        D.22190 = ctx->errors;
        D.22214 = monoeg_g_slist_prepend (D.22190, vinfo);
        ctx->errors = D.22214;
      }
      <D.22211>:
      ctx->valid = 0;
      D.22192 = 0;
      return D.22192;
      <D.22209>:
      i = i + 1;
      <D.17880>:
      size.80 = size;
      if (i < size.80) goto <D.17879>; else goto <D.17881>;
      <D.17881>:
      D.22216 = safe_read_compressed_int (&ptr, end, &size);
      if (D.22216 == 0) goto <D.22217>; else goto <D.22218>;
      <D.22217>:
      D.22186 = ctx->report_error;
      if (D.22186 != 0) goto <D.22219>; else goto <D.22220>;
      <D.22219>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22221 = monoeg_strdup ("ArrayShape: Not enough room for NumLoBounds");
        vinfo->info.message = D.22221;
        vinfo->exception_type = 3;
        D.22190 = ctx->errors;
        D.22222 = monoeg_g_slist_prepend (D.22190, vinfo);
        ctx->errors = D.22222;
      }
      <D.22220>:
      ctx->valid = 0;
      D.22192 = 0;
      return D.22192;
      <D.22218>:
      i = 0;
      goto <D.17885>;
      <D.17884>:
      D.22223 = safe_read_compressed_int (&ptr, end, &num);
      if (D.22223 == 0) goto <D.22224>; else goto <D.22225>;
      <D.22224>:
      D.22186 = ctx->report_error;
      if (D.22186 != 0) goto <D.22226>; else goto <D.22227>;
      <D.22226>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22212 = i + 1;
        D.22228 = monoeg_g_strdup_printf ("ArrayShape: Not enough room for LoBound of rank %d", D.22212);
        vinfo->info.message = D.22228;
        vinfo->exception_type = 3;
        D.22190 = ctx->errors;
        D.22229 = monoeg_g_slist_prepend (D.22190, vinfo);
        ctx->errors = D.22229;
      }
      <D.22227>:
      ctx->valid = 0;
      D.22192 = 0;
      return D.22192;
      <D.22225>:
      i = i + 1;
      <D.17885>:
      size.80 = size;
      if (i < size.80) goto <D.17884>; else goto <D.17886>;
      <D.17886>:
      ptr.81 = ptr;
      *_ptr = ptr.81;
      D.22192 = 1;
      return D.22192;
    }
  finally
    {
      ptr = {CLOBBER};
      val = {CLOBBER};
      size = {CLOBBER};
      num = {CLOBBER};
    }
}


parse_generic_inst (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.82;
  int D.22234;
  int D.22237;
  gchar * D.22240;
  struct GSList * D.22241;
  struct GSList * D.22242;
  gboolean D.22243;
  unsigned int type.83;
  unsigned int D.22245;
  gchar * D.22250;
  struct GSList * D.22251;
  int D.22252;
  gchar * D.22257;
  struct GSList * D.22258;
  unsigned int token.84;
  int D.22262;
  unsigned int D.22264;
  gchar * D.22267;
  struct GSList * D.22268;
  unsigned int D.22269;
  unsigned int D.22272;
  unsigned int D.22273;
  unsigned int D.22276;
  unsigned int D.22277;
  gchar * D.22282;
  struct GSList * D.22283;
  int D.22284;
  gchar * D.22289;
  struct GSList * D.22290;
  unsigned int count.85;
  gchar * D.22296;
  struct GSList * D.22297;
  int D.22298;
  gchar * D.22303;
  struct GSList * D.22304;
  int D.22305;
  unsigned int D.22310;
  gchar * D.22311;
  struct GSList * D.22312;
  const char * ptr.86;
  const char * ptr;
  unsigned int type;
  unsigned int count;
  unsigned int token;
  unsigned int i;

  try
    {
      ptr.82 = *_ptr;
      ptr = ptr.82;
      D.22234 = safe_read (&ptr, end, &type, 1);
      if (D.22234 == 0) goto <D.22235>; else goto <D.22236>;
      <D.22235>:
      D.22237 = ctx->report_error;
      if (D.22237 != 0) goto <D.22238>; else goto <D.22239>;
      <D.22238>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22240 = monoeg_strdup ("GenericInst: Not enough room for kind");
        vinfo->info.message = D.22240;
        vinfo->exception_type = 3;
        D.22241 = ctx->errors;
        D.22242 = monoeg_g_slist_prepend (D.22241, vinfo);
        ctx->errors = D.22242;
      }
      <D.22239>:
      ctx->valid = 0;
      D.22243 = 0;
      return D.22243;
      <D.22236>:
      type.83 = type;
      D.22245 = type.83 + 4294967279;
      if (D.22245 > 1) goto <D.22246>; else goto <D.22247>;
      <D.22246>:
      D.22237 = ctx->report_error;
      if (D.22237 != 0) goto <D.22248>; else goto <D.22249>;
      <D.22248>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        type.83 = type;
        D.22250 = monoeg_g_strdup_printf ("GenericInst: Invalid GenericInst kind %x\n", type.83);
        vinfo->info.message = D.22250;
        vinfo->exception_type = 3;
        D.22241 = ctx->errors;
        D.22251 = monoeg_g_slist_prepend (D.22241, vinfo);
        ctx->errors = D.22251;
      }
      <D.22249>:
      ctx->valid = 0;
      D.22243 = 0;
      return D.22243;
      <D.22247>:
      D.22252 = safe_read_compressed_int (&ptr, end, &token);
      if (D.22252 == 0) goto <D.22253>; else goto <D.22254>;
      <D.22253>:
      D.22237 = ctx->report_error;
      if (D.22237 != 0) goto <D.22255>; else goto <D.22256>;
      <D.22255>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22257 = monoeg_strdup ("GenericInst: Not enough room for type token");
        vinfo->info.message = D.22257;
        vinfo->exception_type = 3;
        D.22241 = ctx->errors;
        D.22258 = monoeg_g_slist_prepend (D.22241, vinfo);
        ctx->errors = D.22258;
      }
      <D.22256>:
      ctx->valid = 0;
      D.22243 = 0;
      return D.22243;
      <D.22254>:
      token.84 = token;
      D.22262 = is_valid_coded_index (ctx, 0, token.84);
      if (D.22262 == 0) goto <D.22259>; else goto <D.22263>;
      <D.22263>:
      token.84 = token;
      D.22264 = get_coded_index_token (0, token.84);
      if (D.22264 == 0) goto <D.22259>; else goto <D.22260>;
      <D.22259>:
      D.22237 = ctx->report_error;
      if (D.22237 != 0) goto <D.22265>; else goto <D.22266>;
      <D.22265>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        token.84 = token;
        D.22267 = monoeg_g_strdup_printf ("GenericInst: invalid TypeDefOrRef token %x", token.84);
        vinfo->info.message = D.22267;
        vinfo->exception_type = 3;
        D.22241 = ctx->errors;
        D.22268 = monoeg_g_slist_prepend (D.22241, vinfo);
        ctx->errors = D.22268;
      }
      <D.22266>:
      ctx->valid = 0;
      D.22243 = 0;
      return D.22243;
      <D.22260>:
      D.22269 = ctx->token;
      if (D.22269 != 0) goto <D.22270>; else goto <D.22271>;
      <D.22270>:
      D.22269 = ctx->token;
      D.22272 = D.22269 & 16777215;
      token.84 = token;
      D.22273 = get_coded_index_token (0, token.84);
      if (D.22272 == D.22273) goto <D.22274>; else goto <D.22275>;
      <D.22274>:
      D.22269 = ctx->token;
      D.22276 = D.22269 >> 24;
      token.84 = token;
      D.22277 = get_coded_index_table (0, token.84);
      if (D.22276 == D.22277) goto <D.22278>; else goto <D.22279>;
      <D.22278>:
      D.22237 = ctx->report_error;
      if (D.22237 != 0) goto <D.22280>; else goto <D.22281>;
      <D.22280>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22269 = ctx->token;
        D.22282 = monoeg_g_strdup_printf ("Type: Recurside generic instance specification (%x). A type signature can\'t reference itself", D.22269);
        vinfo->info.message = D.22282;
        vinfo->exception_type = 3;
        D.22241 = ctx->errors;
        D.22283 = monoeg_g_slist_prepend (D.22241, vinfo);
        ctx->errors = D.22283;
      }
      <D.22281>:
      ctx->valid = 0;
      D.22243 = 0;
      return D.22243;
      <D.22279>:
      <D.22275>:
      <D.22271>:
      D.22284 = safe_read_compressed_int (&ptr, end, &count);
      if (D.22284 == 0) goto <D.22285>; else goto <D.22286>;
      <D.22285>:
      D.22237 = ctx->report_error;
      if (D.22237 != 0) goto <D.22287>; else goto <D.22288>;
      <D.22287>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22289 = monoeg_strdup ("GenericInst: Not enough room for argument count");
        vinfo->info.message = D.22289;
        vinfo->exception_type = 3;
        D.22241 = ctx->errors;
        D.22290 = monoeg_g_slist_prepend (D.22241, vinfo);
        ctx->errors = D.22290;
      }
      <D.22288>:
      ctx->valid = 0;
      D.22243 = 0;
      return D.22243;
      <D.22286>:
      count.85 = count;
      if (count.85 == 0) goto <D.22292>; else goto <D.22293>;
      <D.22292>:
      D.22237 = ctx->report_error;
      if (D.22237 != 0) goto <D.22294>; else goto <D.22295>;
      <D.22294>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22296 = monoeg_strdup ("GenericInst: Zero arguments generic instance");
        vinfo->info.message = D.22296;
        vinfo->exception_type = 3;
        D.22241 = ctx->errors;
        D.22297 = monoeg_g_slist_prepend (D.22241, vinfo);
        ctx->errors = D.22297;
      }
      <D.22295>:
      ctx->valid = 0;
      D.22243 = 0;
      return D.22243;
      <D.22293>:
      i = 0;
      goto <D.17907>;
      <D.17906>:
      D.22298 = parse_custom_mods (ctx, &ptr, end);
      if (D.22298 == 0) goto <D.22299>; else goto <D.22300>;
      <D.22299>:
      D.22237 = ctx->report_error;
      if (D.22237 != 0) goto <D.22301>; else goto <D.22302>;
      <D.22301>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22303 = monoeg_strdup ("Type: Failed to parse pointer custom attr");
        vinfo->info.message = D.22303;
        vinfo->exception_type = 3;
        D.22241 = ctx->errors;
        D.22304 = monoeg_g_slist_prepend (D.22241, vinfo);
        ctx->errors = D.22304;
      }
      <D.22302>:
      ctx->valid = 0;
      D.22243 = 0;
      return D.22243;
      <D.22300>:
      D.22305 = parse_type (ctx, &ptr, end);
      if (D.22305 == 0) goto <D.22306>; else goto <D.22307>;
      <D.22306>:
      D.22237 = ctx->report_error;
      if (D.22237 != 0) goto <D.22308>; else goto <D.22309>;
      <D.22308>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22310 = i + 1;
        D.22311 = monoeg_g_strdup_printf ("GenericInst: invalid generic argument %d", D.22310);
        vinfo->info.message = D.22311;
        vinfo->exception_type = 3;
        D.22241 = ctx->errors;
        D.22312 = monoeg_g_slist_prepend (D.22241, vinfo);
        ctx->errors = D.22312;
      }
      <D.22309>:
      ctx->valid = 0;
      D.22243 = 0;
      return D.22243;
      <D.22307>:
      i = i + 1;
      <D.17907>:
      count.85 = count;
      if (i < count.85) goto <D.17906>; else goto <D.17908>;
      <D.17908>:
      ptr.86 = ptr;
      *_ptr = ptr.86;
      D.22243 = 1;
      return D.22243;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
      count = {CLOBBER};
      token = {CLOBBER};
    }
}


parse_method_signature (struct VerifyContext * ctx, const char * * _ptr, const char * end, gboolean allow_sentinel, gboolean allow_unmanaged)
{
  const char * ptr.87;
  int D.22317;
  int D.22320;
  gchar * D.22323;
  struct GSList * D.22324;
  struct GSList * D.22325;
  gboolean D.22326;
  unsigned int cconv.88;
  unsigned int D.22328;
  gchar * D.22333;
  struct GSList * D.22334;
  unsigned int D.22337;
  gchar * D.22342;
  struct GSList * D.22343;
  unsigned int D.22345;
  _Bool D.22346;
  _Bool D.22347;
  _Bool D.22348;
  gchar * D.22353;
  struct GSList * D.22354;
  unsigned int D.22355;
  int D.22358;
  gchar * D.22363;
  struct GSList * D.22364;
  unsigned int gparam_count.89;
  gchar * D.22372;
  struct GSList * D.22373;
  gchar * D.22380;
  struct GSList * D.22381;
  int D.22382;
  gchar * D.22387;
  struct GSList * D.22388;
  int D.22389;
  gchar * D.22394;
  struct GSList * D.22395;
  int D.22398;
  gchar * D.22403;
  struct GSList * D.22404;
  unsigned int type.90;
  gchar * D.22412;
  struct GSList * D.22413;
  gchar * D.22418;
  struct GSList * D.22419;
  const char * ptr.91;
  const char * ptr.92;
  int D.22423;
  gchar * D.22428;
  struct GSList * D.22429;
  unsigned int param_count.93;
  unsigned int cconv;
  unsigned int param_count;
  unsigned int gparam_count;
  unsigned int type;
  unsigned int i;
  const char * ptr;
  gboolean saw_sentinel;

  try
    {
      cconv = 0;
      param_count = 0;
      gparam_count = 0;
      type = 0;
      ptr.87 = *_ptr;
      ptr = ptr.87;
      saw_sentinel = 0;
      D.22317 = safe_read (&ptr, end, &cconv, 1);
      if (D.22317 == 0) goto <D.22318>; else goto <D.22319>;
      <D.22318>:
      D.22320 = ctx->report_error;
      if (D.22320 != 0) goto <D.22321>; else goto <D.22322>;
      <D.22321>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22323 = monoeg_strdup ("MethodSig: Not enough room for the call conv");
        vinfo->info.message = D.22323;
        vinfo->exception_type = 3;
        D.22324 = ctx->errors;
        D.22325 = monoeg_g_slist_prepend (D.22324, vinfo);
        ctx->errors = D.22325;
      }
      <D.22322>:
      ctx->valid = 0;
      D.22326 = 0;
      return D.22326;
      <D.22319>:
      cconv.88 = cconv;
      D.22328 = cconv.88 & 128;
      if (D.22328 != 0) goto <D.22329>; else goto <D.22330>;
      <D.22329>:
      D.22320 = ctx->report_error;
      if (D.22320 != 0) goto <D.22331>; else goto <D.22332>;
      <D.22331>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22333 = monoeg_strdup ("MethodSig: CallConv has 0x80 set");
        vinfo->info.message = D.22333;
        vinfo->exception_type = 3;
        D.22324 = ctx->errors;
        D.22334 = monoeg_g_slist_prepend (D.22324, vinfo);
        ctx->errors = D.22334;
      }
      <D.22332>:
      ctx->valid = 0;
      D.22326 = 0;
      return D.22326;
      <D.22330>:
      if (allow_unmanaged != 0) goto <D.22335>; else goto <D.22336>;
      <D.22335>:
      cconv.88 = cconv;
      D.22337 = cconv.88 & 15;
      if (D.22337 > 5) goto <D.22338>; else goto <D.22339>;
      <D.22338>:
      D.22320 = ctx->report_error;
      if (D.22320 != 0) goto <D.22340>; else goto <D.22341>;
      <D.22340>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        cconv.88 = cconv;
        D.22337 = cconv.88 & 15;
        D.22342 = monoeg_g_strdup_printf ("MethodSig: CallConv is not valid, it\'s %x", D.22337);
        vinfo->info.message = D.22342;
        vinfo->exception_type = 3;
        D.22324 = ctx->errors;
        D.22343 = monoeg_g_slist_prepend (D.22324, vinfo);
        ctx->errors = D.22343;
      }
      <D.22341>:
      ctx->valid = 0;
      D.22326 = 0;
      return D.22326;
      <D.22339>:
      goto <D.22344>;
      <D.22336>:
      cconv.88 = cconv;
      D.22345 = cconv.88 & 15;
      D.22346 = D.22345 != 0;
      D.22347 = D.22345 != 5;
      D.22348 = D.22346 & D.22347;
      if (D.22348 != 0) goto <D.22349>; else goto <D.22350>;
      <D.22349>:
      D.22320 = ctx->report_error;
      if (D.22320 != 0) goto <D.22351>; else goto <D.22352>;
      <D.22351>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        cconv.88 = cconv;
        D.22337 = cconv.88 & 15;
        D.22353 = monoeg_g_strdup_printf ("MethodSig: CallConv is not Default or Vararg, it\'s %x", D.22337);
        vinfo->info.message = D.22353;
        vinfo->exception_type = 3;
        D.22324 = ctx->errors;
        D.22354 = monoeg_g_slist_prepend (D.22324, vinfo);
        ctx->errors = D.22354;
      }
      <D.22352>:
      ctx->valid = 0;
      D.22326 = 0;
      return D.22326;
      <D.22350>:
      <D.22344>:
      cconv.88 = cconv;
      D.22355 = cconv.88 & 16;
      if (D.22355 != 0) goto <D.22356>; else goto <D.22357>;
      <D.22356>:
      D.22358 = safe_read_compressed_int (&ptr, end, &gparam_count);
      if (D.22358 == 0) goto <D.22359>; else goto <D.22360>;
      <D.22359>:
      D.22320 = ctx->report_error;
      if (D.22320 != 0) goto <D.22361>; else goto <D.22362>;
      <D.22361>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22363 = monoeg_strdup ("MethodSig: Not enough room for the generic param count");
        vinfo->info.message = D.22363;
        vinfo->exception_type = 3;
        D.22324 = ctx->errors;
        D.22364 = monoeg_g_slist_prepend (D.22324, vinfo);
        ctx->errors = D.22364;
      }
      <D.22362>:
      ctx->valid = 0;
      D.22326 = 0;
      return D.22326;
      <D.22360>:
      <D.22357>:
      cconv.88 = cconv;
      D.22355 = cconv.88 & 16;
      if (D.22355 != 0) goto <D.22365>; else goto <D.22366>;
      <D.22365>:
      gparam_count.89 = gparam_count;
      if (gparam_count.89 == 0) goto <D.22368>; else goto <D.22369>;
      <D.22368>:
      D.22320 = ctx->report_error;
      if (D.22320 != 0) goto <D.22370>; else goto <D.22371>;
      <D.22370>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22372 = monoeg_strdup ("MethodSig: Signature with generics but zero arity");
        vinfo->info.message = D.22372;
        vinfo->exception_type = 3;
        D.22324 = ctx->errors;
        D.22373 = monoeg_g_slist_prepend (D.22324, vinfo);
        ctx->errors = D.22373;
      }
      <D.22371>:
      ctx->valid = 0;
      D.22326 = 0;
      return D.22326;
      <D.22369>:
      <D.22366>:
      if (allow_unmanaged != 0) goto <D.22374>; else goto <D.22375>;
      <D.22374>:
      cconv.88 = cconv;
      D.22355 = cconv.88 & 16;
      if (D.22355 != 0) goto <D.22376>; else goto <D.22377>;
      <D.22376>:
      D.22320 = ctx->report_error;
      if (D.22320 != 0) goto <D.22378>; else goto <D.22379>;
      <D.22378>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22380 = monoeg_strdup ("MethodSig: Standalone signature with generic params");
        vinfo->info.message = D.22380;
        vinfo->exception_type = 3;
        D.22324 = ctx->errors;
        D.22381 = monoeg_g_slist_prepend (D.22324, vinfo);
        ctx->errors = D.22381;
      }
      <D.22379>:
      ctx->valid = 0;
      D.22326 = 0;
      return D.22326;
      <D.22377>:
      <D.22375>:
      D.22382 = safe_read_compressed_int (&ptr, end, &param_count);
      if (D.22382 == 0) goto <D.22383>; else goto <D.22384>;
      <D.22383>:
      D.22320 = ctx->report_error;
      if (D.22320 != 0) goto <D.22385>; else goto <D.22386>;
      <D.22385>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22387 = monoeg_strdup ("MethodSig: Not enough room for the param count");
        vinfo->info.message = D.22387;
        vinfo->exception_type = 3;
        D.22324 = ctx->errors;
        D.22388 = monoeg_g_slist_prepend (D.22324, vinfo);
        ctx->errors = D.22388;
      }
      <D.22386>:
      ctx->valid = 0;
      D.22326 = 0;
      return D.22326;
      <D.22384>:
      D.22389 = parse_return_type (ctx, &ptr, end);
      if (D.22389 == 0) goto <D.22390>; else goto <D.22391>;
      <D.22390>:
      D.22320 = ctx->report_error;
      if (D.22320 != 0) goto <D.22392>; else goto <D.22393>;
      <D.22392>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22394 = monoeg_strdup ("MethodSig: Error parsing return type");
        vinfo->info.message = D.22394;
        vinfo->exception_type = 3;
        D.22324 = ctx->errors;
        D.22395 = monoeg_g_slist_prepend (D.22324, vinfo);
        ctx->errors = D.22395;
      }
      <D.22393>:
      ctx->valid = 0;
      D.22326 = 0;
      return D.22326;
      <D.22391>:
      i = 0;
      goto <D.17987>;
      <D.17986>:
      if (allow_sentinel != 0) goto <D.22396>; else goto <D.22397>;
      <D.22396>:
      D.22398 = safe_read (&ptr, end, &type, 1);
      if (D.22398 == 0) goto <D.22399>; else goto <D.22400>;
      <D.22399>:
      D.22320 = ctx->report_error;
      if (D.22320 != 0) goto <D.22401>; else goto <D.22402>;
      <D.22401>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22403 = monoeg_g_strdup_printf ("MethodSig: Not enough room for param %d type", i);
        vinfo->info.message = D.22403;
        vinfo->exception_type = 3;
        D.22324 = ctx->errors;
        D.22404 = monoeg_g_slist_prepend (D.22324, vinfo);
        ctx->errors = D.22404;
      }
      <D.22402>:
      ctx->valid = 0;
      D.22326 = 0;
      return D.22326;
      <D.22400>:
      type.90 = type;
      if (type.90 == 65) goto <D.22406>; else goto <D.22407>;
      <D.22406>:
      cconv.88 = cconv;
      D.22337 = cconv.88 & 15;
      if (D.22337 != 5) goto <D.22408>; else goto <D.22409>;
      <D.22408>:
      D.22320 = ctx->report_error;
      if (D.22320 != 0) goto <D.22410>; else goto <D.22411>;
      <D.22410>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22412 = monoeg_strdup ("MethodSig: Found sentinel but signature is not vararg");
        vinfo->info.message = D.22412;
        vinfo->exception_type = 3;
        D.22324 = ctx->errors;
        D.22413 = monoeg_g_slist_prepend (D.22324, vinfo);
        ctx->errors = D.22413;
      }
      <D.22411>:
      ctx->valid = 0;
      D.22326 = 0;
      return D.22326;
      <D.22409>:
      if (saw_sentinel != 0) goto <D.22414>; else goto <D.22415>;
      <D.22414>:
      D.22320 = ctx->report_error;
      if (D.22320 != 0) goto <D.22416>; else goto <D.22417>;
      <D.22416>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22418 = monoeg_strdup ("MethodSig: More than one sentinel type");
        vinfo->info.message = D.22418;
        vinfo->exception_type = 3;
        D.22324 = ctx->errors;
        D.22419 = monoeg_g_slist_prepend (D.22324, vinfo);
        ctx->errors = D.22419;
      }
      <D.22417>:
      ctx->valid = 0;
      D.22326 = 0;
      return D.22326;
      <D.22415>:
      saw_sentinel = 1;
      goto <D.22420>;
      <D.22407>:
      ptr.91 = ptr;
      ptr.92 = ptr.91 + 4294967295;
      ptr = ptr.92;
      <D.22420>:
      <D.22397>:
      D.22423 = parse_param (ctx, &ptr, end);
      if (D.22423 == 0) goto <D.22424>; else goto <D.22425>;
      <D.22424>:
      D.22320 = ctx->report_error;
      if (D.22320 != 0) goto <D.22426>; else goto <D.22427>;
      <D.22426>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22428 = monoeg_g_strdup_printf ("MethodSig: Error parsing arg %d", i);
        vinfo->info.message = D.22428;
        vinfo->exception_type = 3;
        D.22324 = ctx->errors;
        D.22429 = monoeg_g_slist_prepend (D.22324, vinfo);
        ctx->errors = D.22429;
      }
      <D.22427>:
      ctx->valid = 0;
      D.22326 = 0;
      return D.22326;
      <D.22425>:
      i = i + 1;
      <D.17987>:
      param_count.93 = param_count;
      if (i < param_count.93) goto <D.17986>; else goto <D.17988>;
      <D.17988>:
      ptr.91 = ptr;
      *_ptr = ptr.91;
      D.22326 = 1;
      return D.22326;
    }
  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.22433;
  gboolean D.22436;
  const char * ptr.94;
  int D.22438;
  int D.22441;
  gchar * D.22444;
  struct GSList * D.22445;
  struct GSList * D.22446;
  unsigned int type.95;
  _Bool D.22448;
  _Bool D.22449;
  _Bool D.22450;
  const char * ptr.96;
  unsigned int type.97;
  const char * ptr;
  unsigned int type;

  try
    {
      type = 0;
      D.22433 = parse_custom_mods (ctx, _ptr, end);
      if (D.22433 == 0) goto <D.22434>; else goto <D.22435>;
      <D.22434>:
      D.22436 = 0;
      return D.22436;
      <D.22435>:
      ptr.94 = *_ptr;
      ptr = ptr.94;
      D.22438 = safe_read (&ptr, end, &type, 1);
      if (D.22438 == 0) goto <D.22439>; else goto <D.22440>;
      <D.22439>:
      D.22441 = ctx->report_error;
      if (D.22441 != 0) goto <D.22442>; else goto <D.22443>;
      <D.22442>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22444 = monoeg_strdup ("ReturnType: Not enough room for the type");
        vinfo->info.message = D.22444;
        vinfo->exception_type = 3;
        D.22445 = ctx->errors;
        D.22446 = monoeg_g_slist_prepend (D.22445, vinfo);
        ctx->errors = D.22446;
      }
      <D.22443>:
      ctx->valid = 0;
      D.22436 = 0;
      return D.22436;
      <D.22440>:
      type.95 = type;
      D.22448 = type.95 == 1;
      D.22449 = type.95 == 22;
      D.22450 = D.22448 | D.22449;
      if (D.22450 != 0) goto <D.22451>; else goto <D.22452>;
      <D.22451>:
      ptr.96 = ptr;
      *_ptr = ptr.96;
      D.22436 = 1;
      return D.22436;
      <D.22452>:
      type.97 = type;
      if (type.97 == 16) goto <D.22455>; else goto <D.22456>;
      <D.22455>:
      ptr.96 = ptr;
      *_ptr = ptr.96;
      <D.22456>:
      D.22436 = parse_type (ctx, _ptr, end);
      return D.22436;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
    }
}


parse_param (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  int D.22459;
  gboolean D.22462;
  const char * ptr.98;
  int D.22464;
  int D.22467;
  gchar * D.22470;
  struct GSList * D.22471;
  struct GSList * D.22472;
  unsigned int type.99;
  const char * ptr.100;
  int D.22479;
  const char * ptr;
  unsigned int type;

  try
    {
      type = 0;
      D.22459 = parse_custom_mods (ctx, _ptr, end);
      if (D.22459 == 0) goto <D.22460>; else goto <D.22461>;
      <D.22460>:
      D.22462 = 0;
      return D.22462;
      <D.22461>:
      ptr.98 = *_ptr;
      ptr = ptr.98;
      D.22464 = safe_read (&ptr, end, &type, 1);
      if (D.22464 == 0) goto <D.22465>; else goto <D.22466>;
      <D.22465>:
      D.22467 = ctx->report_error;
      if (D.22467 != 0) goto <D.22468>; else goto <D.22469>;
      <D.22468>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22470 = monoeg_strdup ("Param: Not enough room for the type");
        vinfo->info.message = D.22470;
        vinfo->exception_type = 3;
        D.22471 = ctx->errors;
        D.22472 = monoeg_g_slist_prepend (D.22471, vinfo);
        ctx->errors = D.22472;
      }
      <D.22469>:
      ctx->valid = 0;
      D.22462 = 0;
      return D.22462;
      <D.22466>:
      type.99 = type;
      if (type.99 == 22) goto <D.22474>; else goto <D.22475>;
      <D.22474>:
      ptr.100 = ptr;
      *_ptr = ptr.100;
      D.22462 = 1;
      return D.22462;
      <D.22475>:
      type.99 = type;
      if (type.99 == 16) goto <D.22477>; else goto <D.22478>;
      <D.22477>:
      ptr.100 = ptr;
      *_ptr = ptr.100;
      D.22479 = parse_custom_mods (ctx, _ptr, end);
      if (D.22479 == 0) goto <D.22480>; else goto <D.22481>;
      <D.22480>:
      D.22462 = 0;
      return D.22462;
      <D.22481>:
      <D.22478>:
      D.22462 = parse_type (ctx, _ptr, end);
      return D.22462;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
    }
}


verify_methodimpl_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22484;
  unsigned int D.22487;
  <unnamed-unsigned:24> D.22489;
  int D.22490;
  int D.22491;
  unsigned int D.22492;
  int D.22493;
  unsigned int D.22496;
  gchar * D.22497;
  struct GSList * D.22498;
  struct GSList * D.22499;
  unsigned int D.22500;
  unsigned int D.22501;
  gchar * D.22506;
  struct GSList * D.22507;
  int D.22508;
  gchar * D.22513;
  struct GSList * D.22514;
  unsigned int D.22515;
  gchar * D.22520;
  struct GSList * D.22521;
  int D.22522;
  gchar * D.22527;
  struct GSList * D.22528;
  <unnamed-unsigned:24> D.22529;
  int D.22530;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.22484 = ctx->image;
      table = &D.22484->tables[25];
      i = 0;
      goto <D.18836>;
      <D.18835>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.22487 = data[0];
      if (D.22487 == 0) goto <D.22485>; else goto <D.22488>;
      <D.22488>:
      D.22487 = data[0];
      D.22484 = ctx->image;
      D.22489 = D.22484->tables[2].rows;
      D.22490 = (int) D.22489;
      D.22491 = D.22490 + 1;
      D.22492 = (unsigned int) D.22491;
      if (D.22487 > D.22492) goto <D.22485>; else goto <D.22486>;
      <D.22485>:
      D.22493 = ctx->report_error;
      if (D.22493 != 0) goto <D.22494>; else goto <D.22495>;
      <D.22494>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22496 = data[2];
        D.22497 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d Class field %08x", i, D.22496);
        vinfo->info.message = D.22497;
        vinfo->exception_type = 3;
        D.22498 = ctx->errors;
        D.22499 = monoeg_g_slist_prepend (D.22498, vinfo);
        ctx->errors = D.22499;
      }
      <D.22495>:
      ctx->valid = 0;
      return;
      <D.22486>:
      D.22500 = data[1];
      D.22501 = get_coded_index_token (52, D.22500);
      if (D.22501 == 0) goto <D.22502>; else goto <D.22503>;
      <D.22502>:
      D.22493 = ctx->report_error;
      if (D.22493 != 0) goto <D.22504>; else goto <D.22505>;
      <D.22504>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22500 = data[1];
        D.22506 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodBody field %08x", i, D.22500);
        vinfo->info.message = D.22506;
        vinfo->exception_type = 3;
        D.22498 = ctx->errors;
        D.22507 = monoeg_g_slist_prepend (D.22498, vinfo);
        ctx->errors = D.22507;
      }
      <D.22505>:
      ctx->valid = 0;
      return;
      <D.22503>:
      D.22500 = data[1];
      D.22508 = is_valid_coded_index (ctx, 52, D.22500);
      if (D.22508 == 0) goto <D.22509>; else goto <D.22510>;
      <D.22509>:
      D.22493 = ctx->report_error;
      if (D.22493 != 0) goto <D.22511>; else goto <D.22512>;
      <D.22511>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22500 = data[1];
        D.22513 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodBody field %08x", i, D.22500);
        vinfo->info.message = D.22513;
        vinfo->exception_type = 3;
        D.22498 = ctx->errors;
        D.22514 = monoeg_g_slist_prepend (D.22498, vinfo);
        ctx->errors = D.22514;
      }
      <D.22512>:
      ctx->valid = 0;
      return;
      <D.22510>:
      D.22496 = data[2];
      D.22515 = get_coded_index_token (52, D.22496);
      if (D.22515 == 0) goto <D.22516>; else goto <D.22517>;
      <D.22516>:
      D.22493 = ctx->report_error;
      if (D.22493 != 0) goto <D.22518>; else goto <D.22519>;
      <D.22518>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22496 = data[2];
        D.22520 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodDeclaration field %08x", i, D.22496);
        vinfo->info.message = D.22520;
        vinfo->exception_type = 3;
        D.22498 = ctx->errors;
        D.22521 = monoeg_g_slist_prepend (D.22498, vinfo);
        ctx->errors = D.22521;
      }
      <D.22519>:
      ctx->valid = 0;
      return;
      <D.22517>:
      D.22496 = data[2];
      D.22522 = is_valid_coded_index (ctx, 52, D.22496);
      if (D.22522 == 0) goto <D.22523>; else goto <D.22524>;
      <D.22523>:
      D.22493 = ctx->report_error;
      if (D.22493 != 0) goto <D.22525>; else goto <D.22526>;
      <D.22525>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22496 = data[2];
        D.22527 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodDeclaration field %08x", i, D.22496);
        vinfo->info.message = D.22527;
        vinfo->exception_type = 3;
        D.22498 = ctx->errors;
        D.22528 = monoeg_g_slist_prepend (D.22498, vinfo);
        ctx->errors = D.22528;
      }
      <D.22526>:
      ctx->valid = 0;
      return;
      <D.22524>:
      i = i + 1;
      <D.18836>:
      D.22529 = table->rows;
      D.22530 = (int) D.22529;
      if (D.22530 > i) goto <D.18835>; else goto <D.18837>;
      <D.18837>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_moduleref_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22534;
  unsigned int D.22535;
  int D.22536;
  int D.22539;
  gchar * D.22542;
  struct GSList * D.22543;
  struct GSList * D.22544;
  <unnamed-unsigned:24> D.22545;
  int D.22546;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.22534 = ctx->image;
      table = &D.22534->tables[26];
      i = 0;
      goto <D.18846>;
      <D.18845>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.22535 = data[0];
      D.22536 = is_valid_non_empty_string (ctx, D.22535);
      if (D.22536 == 0) goto <D.22537>; else goto <D.22538>;
      <D.22537>:
      D.22539 = ctx->report_error;
      if (D.22539 != 0) goto <D.22540>; else goto <D.22541>;
      <D.22540>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22535 = data[0];
        D.22542 = monoeg_g_strdup_printf ("Invalid ModuleRef row %d name field %08x", i, D.22535);
        vinfo->info.message = D.22542;
        vinfo->exception_type = 3;
        D.22543 = ctx->errors;
        D.22544 = monoeg_g_slist_prepend (D.22543, vinfo);
        ctx->errors = D.22544;
      }
      <D.22541>:
      ctx->valid = 0;
      return;
      <D.22538>:
      i = i + 1;
      <D.18846>:
      D.22545 = table->rows;
      D.22546 = (int) D.22545;
      if (D.22546 > i) goto <D.18845>; else goto <D.18847>;
      <D.18847>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_typespec_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22550;
  unsigned int D.22551;
  int D.22554;
  int D.22557;
  gchar * D.22560;
  struct GSList * D.22561;
  struct GSList * D.22562;
  <unnamed-unsigned:24> D.22563;
  int D.22564;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.22550 = ctx->image;
      table = &D.22550->tables[27];
      i = 0;
      goto <D.18856>;
      <D.18855>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.22551 = data[0];
      if (D.22551 != 0) goto <D.22552>; else goto <D.22553>;
      <D.22552>:
      D.22551 = data[0];
      D.22554 = is_valid_blob_object (ctx, D.22551, 1);
      if (D.22554 == 0) goto <D.22555>; else goto <D.22556>;
      <D.22555>:
      D.22557 = ctx->report_error;
      if (D.22557 != 0) goto <D.22558>; else goto <D.22559>;
      <D.22558>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22551 = data[0];
        D.22560 = monoeg_g_strdup_printf ("Invalid TypeSpec row %d Signature field %08x", i, D.22551);
        vinfo->info.message = D.22560;
        vinfo->exception_type = 3;
        D.22561 = ctx->errors;
        D.22562 = monoeg_g_slist_prepend (D.22561, vinfo);
        ctx->errors = D.22562;
      }
      <D.22559>:
      ctx->valid = 0;
      return;
      <D.22556>:
      <D.22553>:
      i = i + 1;
      <D.18856>:
      D.22563 = table->rows;
      D.22564 = (int) D.22563;
      if (D.22564 > i) goto <D.18855>; else goto <D.18857>;
      <D.18857>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_implmap_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22568;
  unsigned int D.22569;
  unsigned int D.22570;
  int D.22573;
  gchar * D.22576;
  struct GSList * D.22577;
  struct GSList * D.22578;
  _Bool D.22581;
  _Bool D.22582;
  _Bool D.22583;
  gchar * D.22587;
  struct GSList * D.22588;
  unsigned int D.22589;
  int D.22590;
  gchar * D.22595;
  struct GSList * D.22596;
  unsigned int D.22597;
  gchar * D.22602;
  struct GSList * D.22603;
  unsigned int D.22604;
  gchar * D.22609;
  struct GSList * D.22610;
  unsigned int D.22611;
  int D.22612;
  gchar * D.22617;
  struct GSList * D.22618;
  unsigned int D.22621;
  <unnamed-unsigned:24> D.22623;
  unsigned int D.22624;
  gchar * D.22627;
  struct GSList * D.22628;
  <unnamed-unsigned:24> D.22629;
  int D.22630;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 cconv;
  int i;

  try
    {
      D.22568 = ctx->image;
      table = &D.22568->tables[28];
      i = 0;
      goto <D.18883>;
      <D.18882>:
      mono_metadata_decode_row (table, i, &data, 4);
      D.22569 = data[0];
      D.22570 = D.22569 & 4294953096;
      if (D.22570 != 0) goto <D.22571>; else goto <D.22572>;
      <D.22571>:
      D.22573 = ctx->report_error;
      if (D.22573 != 0) goto <D.22574>; else goto <D.22575>;
      <D.22574>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22569 = data[0];
        D.22576 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Flags field %08x", i, D.22569);
        vinfo->info.message = D.22576;
        vinfo->exception_type = 3;
        D.22577 = ctx->errors;
        D.22578 = monoeg_g_slist_prepend (D.22577, vinfo);
        ctx->errors = D.22578;
      }
      <D.22575>:
      ctx->valid = 0;
      return;
      <D.22572>:
      D.22569 = data[0];
      cconv = D.22569 & 1792;
      D.22581 = cconv == 0;
      D.22582 = cconv == 1536;
      D.22583 = D.22581 | D.22582;
      if (D.22583 != 0) goto <D.22579>; else goto <D.22584>;
      <D.22584>:
      if (cconv == 1792) goto <D.22579>; else goto <D.22580>;
      <D.22579>:
      D.22573 = ctx->report_error;
      if (D.22573 != 0) goto <D.22585>; else goto <D.22586>;
      <D.22585>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22587 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Invalid call conv field %x", i, cconv);
        vinfo->info.message = D.22587;
        vinfo->exception_type = 3;
        D.22577 = ctx->errors;
        D.22588 = monoeg_g_slist_prepend (D.22577, vinfo);
        ctx->errors = D.22588;
      }
      <D.22586>:
      ctx->valid = 0;
      return;
      <D.22580>:
      D.22589 = data[1];
      D.22590 = is_valid_coded_index (ctx, 56, D.22589);
      if (D.22590 == 0) goto <D.22591>; else goto <D.22592>;
      <D.22591>:
      D.22573 = ctx->report_error;
      if (D.22573 != 0) goto <D.22593>; else goto <D.22594>;
      <D.22593>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22589 = data[1];
        D.22595 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Invalid MemberForward token %x", i, D.22589);
        vinfo->info.message = D.22595;
        vinfo->exception_type = 3;
        D.22577 = ctx->errors;
        D.22596 = monoeg_g_slist_prepend (D.22577, vinfo);
        ctx->errors = D.22596;
      }
      <D.22594>:
      ctx->valid = 0;
      return;
      <D.22592>:
      D.22589 = data[1];
      D.22597 = get_coded_index_table (56, D.22589);
      if (D.22597 != 6) goto <D.22598>; else goto <D.22599>;
      <D.22598>:
      D.22573 = ctx->report_error;
      if (D.22573 != 0) goto <D.22600>; else goto <D.22601>;
      <D.22600>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22589 = data[1];
        D.22602 = monoeg_g_strdup_printf ("Invalid ImplMap row %d only methods are supported token %x", i, D.22589);
        vinfo->info.message = D.22602;
        vinfo->exception_type = 3;
        D.22577 = ctx->errors;
        D.22603 = monoeg_g_slist_prepend (D.22577, vinfo);
        ctx->errors = D.22603;
      }
      <D.22601>:
      ctx->valid = 0;
      return;
      <D.22599>:
      D.22589 = data[1];
      D.22604 = get_coded_index_token (56, D.22589);
      if (D.22604 == 0) goto <D.22605>; else goto <D.22606>;
      <D.22605>:
      D.22573 = ctx->report_error;
      if (D.22573 != 0) goto <D.22607>; else goto <D.22608>;
      <D.22607>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22609 = monoeg_g_strdup_printf ("Invalid ImplMap row %d null token", i);
        vinfo->info.message = D.22609;
        vinfo->exception_type = 3;
        D.22577 = ctx->errors;
        D.22610 = monoeg_g_slist_prepend (D.22577, vinfo);
        ctx->errors = D.22610;
      }
      <D.22608>:
      ctx->valid = 0;
      return;
      <D.22606>:
      D.22611 = data[2];
      D.22612 = is_valid_non_empty_string (ctx, D.22611);
      if (D.22612 == 0) goto <D.22613>; else goto <D.22614>;
      <D.22613>:
      D.22573 = ctx->report_error;
      if (D.22573 != 0) goto <D.22615>; else goto <D.22616>;
      <D.22615>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22611 = data[2];
        D.22617 = monoeg_g_strdup_printf ("Invalid ImplMap row %d ImportName Token %x", i, D.22611);
        vinfo->info.message = D.22617;
        vinfo->exception_type = 3;
        D.22577 = ctx->errors;
        D.22618 = monoeg_g_slist_prepend (D.22577, vinfo);
        ctx->errors = D.22618;
      }
      <D.22616>:
      ctx->valid = 0;
      return;
      <D.22614>:
      D.22621 = data[3];
      if (D.22621 == 0) goto <D.22619>; else goto <D.22622>;
      <D.22622>:
      D.22621 = data[3];
      D.22568 = ctx->image;
      D.22623 = D.22568->tables[26].rows;
      D.22624 = (unsigned int) D.22623;
      if (D.22621 > D.22624) goto <D.22619>; else goto <D.22620>;
      <D.22619>:
      D.22573 = ctx->report_error;
      if (D.22573 != 0) goto <D.22625>; else goto <D.22626>;
      <D.22625>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22621 = data[3];
        D.22627 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Invalid ImportScope token %x", i, D.22621);
        vinfo->info.message = D.22627;
        vinfo->exception_type = 3;
        D.22577 = ctx->errors;
        D.22628 = monoeg_g_slist_prepend (D.22577, vinfo);
        ctx->errors = D.22628;
      }
      <D.22626>:
      ctx->valid = 0;
      return;
      <D.22620>:
      i = i + 1;
      <D.18883>:
      D.22629 = table->rows;
      D.22630 = (int) D.22629;
      if (D.22630 > i) goto <D.18882>; else goto <D.18884>;
      <D.18884>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_fieldrva_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22634;
  unsigned int D.22637;
  unsigned int D.22639;
  int D.22640;
  gchar * D.22643;
  struct GSList * D.22644;
  struct GSList * D.22645;
  unsigned int D.22648;
  <unnamed-unsigned:24> D.22650;
  int D.22651;
  int D.22652;
  unsigned int D.22653;
  gchar * D.22656;
  struct GSList * D.22657;
  <unnamed-unsigned:24> D.22658;
  int D.22659;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.22634 = ctx->image;
      table = &D.22634->tables[29];
      i = 0;
      goto <D.18894>;
      <D.18893>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.22637 = data[0];
      if (D.22637 == 0) goto <D.22635>; else goto <D.22638>;
      <D.22638>:
      D.22637 = data[0];
      D.22634 = ctx->image;
      D.22639 = mono_cli_rva_image_map (D.22634, D.22637);
      if (D.22639 == 4294967295) goto <D.22635>; else goto <D.22636>;
      <D.22635>:
      D.22640 = ctx->report_error;
      if (D.22640 != 0) goto <D.22641>; else goto <D.22642>;
      <D.22641>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22637 = data[0];
        D.22643 = monoeg_g_strdup_printf ("Invalid FieldRVA row %d RVA %08x", i, D.22637);
        vinfo->info.message = D.22643;
        vinfo->exception_type = 3;
        D.22644 = ctx->errors;
        D.22645 = monoeg_g_slist_prepend (D.22644, vinfo);
        ctx->errors = D.22645;
      }
      <D.22642>:
      ctx->valid = 0;
      return;
      <D.22636>:
      D.22648 = data[1];
      if (D.22648 == 0) goto <D.22646>; else goto <D.22649>;
      <D.22649>:
      D.22648 = data[1];
      D.22634 = ctx->image;
      D.22650 = D.22634->tables[4].rows;
      D.22651 = (int) D.22650;
      D.22652 = D.22651 + 1;
      D.22653 = (unsigned int) D.22652;
      if (D.22648 > D.22653) goto <D.22646>; else goto <D.22647>;
      <D.22646>:
      D.22640 = ctx->report_error;
      if (D.22640 != 0) goto <D.22654>; else goto <D.22655>;
      <D.22654>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22648 = data[1];
        D.22656 = monoeg_g_strdup_printf ("Invalid FieldRVA row %d Field %08x", i, D.22648);
        vinfo->info.message = D.22656;
        vinfo->exception_type = 3;
        D.22644 = ctx->errors;
        D.22657 = monoeg_g_slist_prepend (D.22644, vinfo);
        ctx->errors = D.22657;
      }
      <D.22655>:
      ctx->valid = 0;
      return;
      <D.22647>:
      i = i + 1;
      <D.18894>:
      D.22658 = table->rows;
      D.22659 = (int) D.22658;
      if (D.22659 > i) goto <D.18893>; else goto <D.18895>;
      <D.18895>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_assembly_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22663;
  <unnamed-unsigned:24> D.22664;
  int D.22665;
  int D.22668;
  gchar * D.22671;
  struct GSList * D.22672;
  struct GSList * D.22673;
  _Bool D.22674;
  _Bool D.22675;
  _Bool D.22676;
  gchar * D.22683;
  struct GSList * D.22684;
  unsigned int D.22685;
  unsigned int D.22686;
  gchar * D.22691;
  struct GSList * D.22692;
  unsigned int D.22693;
  int D.22696;
  gchar * D.22701;
  struct GSList * D.22702;
  unsigned int D.22703;
  int D.22704;
  gchar * D.22709;
  struct GSList * D.22710;
  unsigned int D.22711;
  int D.22714;
  gchar * D.22719;
  struct GSList * D.22720;
  struct MonoTableInfo * table;
  guint32 data[9];
  guint32 hash;
  int i;

  try
    {
      D.22663 = ctx->image;
      table = &D.22663->tables[32];
      D.22664 = table->rows;
      D.22665 = (int) D.22664;
      if (D.22665 > 1) 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 (12);
        vinfo->info.status = 1;
        D.22664 = table->rows;
        D.22665 = (int) D.22664;
        D.22671 = monoeg_g_strdup_printf ("Assembly table can have zero or one rows, but now %d", D.22665);
        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>:
      i = 0;
      goto <D.18910>;
      <D.18909>:
      mono_metadata_decode_row (table, i, &data, 9);
      hash = data[0];
      D.22674 = hash != 0;
      D.22675 = hash != 32771;
      D.22676 = D.22674 & D.22675;
      if (D.22676 != 0) goto <D.22677>; else goto <D.22678>;
      <D.22677>:
      if (hash != 32772) goto <D.22679>; else goto <D.22680>;
      <D.22679>:
      D.22668 = ctx->report_error;
      if (D.22668 != 0) goto <D.22681>; else goto <D.22682>;
      <D.22681>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22683 = monoeg_g_strdup_printf ("Assembly table row %d has invalid HashAlgId %x", i, hash);
        vinfo->info.message = D.22683;
        vinfo->exception_type = 3;
        D.22672 = ctx->errors;
        D.22684 = monoeg_g_slist_prepend (D.22672, vinfo);
        ctx->errors = D.22684;
      }
      <D.22682>:
      ctx->valid = 0;
      return;
      <D.22680>:
      <D.22678>:
      D.22685 = data[5];
      D.22686 = D.22685 & 4294917646;
      if (D.22686 != 0) goto <D.22687>; else goto <D.22688>;
      <D.22687>:
      D.22668 = ctx->report_error;
      if (D.22668 != 0) goto <D.22689>; else goto <D.22690>;
      <D.22689>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22685 = data[5];
        D.22691 = monoeg_g_strdup_printf ("Assembly table row %d has invalid Flags %08x", i, D.22685);
        vinfo->info.message = D.22691;
        vinfo->exception_type = 3;
        D.22672 = ctx->errors;
        D.22692 = monoeg_g_slist_prepend (D.22672, vinfo);
        ctx->errors = D.22692;
      }
      <D.22690>:
      ctx->valid = 0;
      return;
      <D.22688>:
      D.22693 = data[6];
      if (D.22693 != 0) goto <D.22694>; else goto <D.22695>;
      <D.22694>:
      D.22693 = data[6];
      D.22696 = is_valid_blob_object (ctx, D.22693, 1);
      if (D.22696 == 0) goto <D.22697>; else goto <D.22698>;
      <D.22697>:
      D.22668 = ctx->report_error;
      if (D.22668 != 0) goto <D.22699>; else goto <D.22700>;
      <D.22699>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22685 = data[5];
        D.22701 = monoeg_g_strdup_printf ("Assembly table row %d has invalid PublicKey %08x", i, D.22685);
        vinfo->info.message = D.22701;
        vinfo->exception_type = 3;
        D.22672 = ctx->errors;
        D.22702 = monoeg_g_slist_prepend (D.22672, vinfo);
        ctx->errors = D.22702;
      }
      <D.22700>:
      ctx->valid = 0;
      return;
      <D.22698>:
      <D.22695>:
      D.22703 = data[7];
      D.22704 = is_valid_non_empty_string (ctx, D.22703);
      if (D.22704 == 0) goto <D.22705>; else goto <D.22706>;
      <D.22705>:
      D.22668 = ctx->report_error;
      if (D.22668 != 0) goto <D.22707>; else goto <D.22708>;
      <D.22707>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22703 = data[7];
        D.22709 = monoeg_g_strdup_printf ("Assembly table row %d has invalid Name %08x", i, D.22703);
        vinfo->info.message = D.22709;
        vinfo->exception_type = 3;
        D.22672 = ctx->errors;
        D.22710 = monoeg_g_slist_prepend (D.22672, vinfo);
        ctx->errors = D.22710;
      }
      <D.22708>:
      ctx->valid = 0;
      return;
      <D.22706>:
      D.22711 = data[8];
      if (D.22711 != 0) goto <D.22712>; else goto <D.22713>;
      <D.22712>:
      D.22711 = data[8];
      D.22714 = is_valid_string (ctx, D.22711);
      if (D.22714 == 0) goto <D.22715>; else goto <D.22716>;
      <D.22715>:
      D.22668 = ctx->report_error;
      if (D.22668 != 0) goto <D.22717>; else goto <D.22718>;
      <D.22717>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22711 = data[8];
        D.22719 = monoeg_g_strdup_printf ("Assembly table row %d has invalid Culture %08x", i, D.22711);
        vinfo->info.message = D.22719;
        vinfo->exception_type = 3;
        D.22672 = ctx->errors;
        D.22720 = monoeg_g_slist_prepend (D.22672, vinfo);
        ctx->errors = D.22720;
      }
      <D.22718>:
      ctx->valid = 0;
      return;
      <D.22716>:
      <D.22713>:
      i = i + 1;
      <D.18910>:
      D.22664 = table->rows;
      D.22665 = (int) D.22664;
      if (D.22665 > i) goto <D.18909>; else goto <D.18911>;
      <D.18911>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_assemblyref_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22724;
  unsigned int D.22725;
  unsigned int D.22726;
  int D.22729;
  gchar * D.22732;
  struct GSList * D.22733;
  struct GSList * D.22734;
  unsigned int D.22735;
  int D.22738;
  gchar * D.22743;
  struct GSList * D.22744;
  unsigned int D.22745;
  int D.22746;
  gchar * D.22751;
  struct GSList * D.22752;
  unsigned int D.22753;
  int D.22756;
  gchar * D.22761;
  struct GSList * D.22762;
  unsigned int D.22763;
  int D.22766;
  gchar * D.22771;
  struct GSList * D.22772;
  <unnamed-unsigned:24> D.22773;
  int D.22774;
  struct MonoTableInfo * table;
  guint32 data[9];
  int i;

  try
    {
      D.22724 = ctx->image;
      table = &D.22724->tables[35];
      i = 0;
      goto <D.18924>;
      <D.18923>:
      mono_metadata_decode_row (table, i, &data, 9);
      D.22725 = data[4];
      D.22726 = D.22725 & 4294917886;
      if (D.22726 != 0) goto <D.22727>; else goto <D.22728>;
      <D.22727>:
      D.22729 = ctx->report_error;
      if (D.22729 != 0) goto <D.22730>; else goto <D.22731>;
      <D.22730>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22725 = data[4];
        D.22732 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid Flags %08x", i, D.22725);
        vinfo->info.message = D.22732;
        vinfo->exception_type = 3;
        D.22733 = ctx->errors;
        D.22734 = monoeg_g_slist_prepend (D.22733, vinfo);
        ctx->errors = D.22734;
      }
      <D.22731>:
      ctx->valid = 0;
      return;
      <D.22728>:
      D.22735 = data[5];
      if (D.22735 != 0) goto <D.22736>; else goto <D.22737>;
      <D.22736>:
      D.22735 = data[5];
      D.22738 = is_valid_blob_object (ctx, D.22735, 1);
      if (D.22738 == 0) goto <D.22739>; else goto <D.22740>;
      <D.22739>:
      D.22729 = ctx->report_error;
      if (D.22729 != 0) goto <D.22741>; else goto <D.22742>;
      <D.22741>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22735 = data[5];
        D.22743 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid PublicKeyOrToken %08x", i, D.22735);
        vinfo->info.message = D.22743;
        vinfo->exception_type = 3;
        D.22733 = ctx->errors;
        D.22744 = monoeg_g_slist_prepend (D.22733, vinfo);
        ctx->errors = D.22744;
      }
      <D.22742>:
      ctx->valid = 0;
      return;
      <D.22740>:
      <D.22737>:
      D.22745 = data[6];
      D.22746 = is_valid_non_empty_string (ctx, D.22745);
      if (D.22746 == 0) goto <D.22747>; else goto <D.22748>;
      <D.22747>:
      D.22729 = ctx->report_error;
      if (D.22729 != 0) goto <D.22749>; else goto <D.22750>;
      <D.22749>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22745 = data[6];
        D.22751 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid Name %08x", i, D.22745);
        vinfo->info.message = D.22751;
        vinfo->exception_type = 3;
        D.22733 = ctx->errors;
        D.22752 = monoeg_g_slist_prepend (D.22733, vinfo);
        ctx->errors = D.22752;
      }
      <D.22750>:
      ctx->valid = 0;
      return;
      <D.22748>:
      D.22753 = data[7];
      if (D.22753 != 0) goto <D.22754>; else goto <D.22755>;
      <D.22754>:
      D.22753 = data[7];
      D.22756 = is_valid_string (ctx, D.22753);
      if (D.22756 == 0) goto <D.22757>; else goto <D.22758>;
      <D.22757>:
      D.22729 = ctx->report_error;
      if (D.22729 != 0) goto <D.22759>; else goto <D.22760>;
      <D.22759>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22753 = data[7];
        D.22761 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid Culture %08x", i, D.22753);
        vinfo->info.message = D.22761;
        vinfo->exception_type = 3;
        D.22733 = ctx->errors;
        D.22762 = monoeg_g_slist_prepend (D.22733, vinfo);
        ctx->errors = D.22762;
      }
      <D.22760>:
      ctx->valid = 0;
      return;
      <D.22758>:
      <D.22755>:
      D.22763 = data[8];
      if (D.22763 != 0) goto <D.22764>; else goto <D.22765>;
      <D.22764>:
      D.22763 = data[8];
      D.22766 = is_valid_blob_object (ctx, D.22763, 1);
      if (D.22766 == 0) goto <D.22767>; else goto <D.22768>;
      <D.22767>:
      D.22729 = ctx->report_error;
      if (D.22729 != 0) goto <D.22769>; else goto <D.22770>;
      <D.22769>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22763 = data[8];
        D.22771 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid HashValue %08x", i, D.22763);
        vinfo->info.message = D.22771;
        vinfo->exception_type = 3;
        D.22733 = ctx->errors;
        D.22772 = monoeg_g_slist_prepend (D.22733, vinfo);
        ctx->errors = D.22772;
      }
      <D.22770>:
      ctx->valid = 0;
      return;
      <D.22768>:
      <D.22765>:
      i = i + 1;
      <D.18924>:
      D.22773 = table->rows;
      D.22774 = (int) D.22773;
      if (D.22774 > i) goto <D.18923>; else goto <D.18925>;
      <D.18925>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_file_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22778;
  unsigned int D.22779;
  unsigned int D.22780;
  int D.22783;
  gchar * D.22786;
  struct GSList * D.22787;
  struct GSList * D.22788;
  unsigned int D.22789;
  int D.22790;
  gchar * D.22795;
  struct GSList * D.22796;
  unsigned int D.22799;
  int D.22801;
  gchar * D.22804;
  struct GSList * D.22805;
  <unnamed-unsigned:24> D.22806;
  int D.22807;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.22778 = ctx->image;
      table = &D.22778->tables[38];
      i = 0;
      goto <D.18936>;
      <D.18935>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.22779 = data[0];
      D.22780 = D.22779 & 4294967294;
      if (D.22780 != 0) goto <D.22781>; else goto <D.22782>;
      <D.22781>:
      D.22783 = ctx->report_error;
      if (D.22783 != 0) goto <D.22784>; else goto <D.22785>;
      <D.22784>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22779 = data[0];
        D.22786 = monoeg_g_strdup_printf ("File table row %d has invalid Flags %08x", i, D.22779);
        vinfo->info.message = D.22786;
        vinfo->exception_type = 3;
        D.22787 = ctx->errors;
        D.22788 = monoeg_g_slist_prepend (D.22787, vinfo);
        ctx->errors = D.22788;
      }
      <D.22785>:
      ctx->valid = 0;
      return;
      <D.22782>:
      D.22789 = data[1];
      D.22790 = is_valid_non_empty_string (ctx, D.22789);
      if (D.22790 == 0) goto <D.22791>; else goto <D.22792>;
      <D.22791>:
      D.22783 = ctx->report_error;
      if (D.22783 != 0) goto <D.22793>; else goto <D.22794>;
      <D.22793>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22789 = data[1];
        D.22795 = monoeg_g_strdup_printf ("File table row %d has invalid Name %08x", i, D.22789);
        vinfo->info.message = D.22795;
        vinfo->exception_type = 3;
        D.22787 = ctx->errors;
        D.22796 = monoeg_g_slist_prepend (D.22787, vinfo);
        ctx->errors = D.22796;
      }
      <D.22794>:
      ctx->valid = 0;
      return;
      <D.22792>:
      D.22799 = data[2];
      if (D.22799 == 0) goto <D.22797>; else goto <D.22800>;
      <D.22800>:
      D.22799 = data[2];
      D.22801 = is_valid_blob_object (ctx, D.22799, 1);
      if (D.22801 == 0) goto <D.22797>; else goto <D.22798>;
      <D.22797>:
      D.22783 = ctx->report_error;
      if (D.22783 != 0) goto <D.22802>; else goto <D.22803>;
      <D.22802>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22799 = data[2];
        D.22804 = monoeg_g_strdup_printf ("File table row %d has invalid HashValue %08x", i, D.22799);
        vinfo->info.message = D.22804;
        vinfo->exception_type = 3;
        D.22787 = ctx->errors;
        D.22805 = monoeg_g_slist_prepend (D.22787, vinfo);
        ctx->errors = D.22805;
      }
      <D.22803>:
      ctx->valid = 0;
      return;
      <D.22798>:
      i = i + 1;
      <D.18936>:
      D.22806 = table->rows;
      D.22807 = (int) D.22806;
      if (D.22807 > i) goto <D.18935>; else goto <D.18937>;
      <D.18937>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_exportedtype_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22811;
  unsigned int D.22812;
  unsigned int D.22813;
  int D.22816;
  gchar * D.22819;
  struct GSList * D.22820;
  struct GSList * D.22821;
  unsigned int D.22822;
  int D.22823;
  unsigned int D.22828;
  gchar * D.22829;
  struct GSList * D.22830;
  unsigned int D.22831;
  int D.22834;
  gchar * D.22839;
  struct GSList * D.22840;
  unsigned int D.22841;
  int D.22842;
  gchar * D.22847;
  struct GSList * D.22848;
  unsigned int D.22849;
  gchar * D.22854;
  struct GSList * D.22855;
  unsigned int D.22856;
  gchar * D.22863;
  struct GSList * D.22864;
  <unnamed-unsigned:24> D.22865;
  int D.22866;
  struct MonoTableInfo * table;
  guint32 data[5];
  int i;

  try
    {
      D.22811 = ctx->image;
      table = &D.22811->tables[39];
      i = 0;
      goto <D.18951>;
      <D.18950>:
      mono_metadata_decode_row (table, i, &data, 5);
      D.22812 = data[0];
      D.22813 = D.22812 & 4278764096;
      if (D.22813 != 0) goto <D.22814>; else goto <D.22815>;
      <D.22814>:
      D.22816 = ctx->report_error;
      if (D.22816 != 0) goto <D.22817>; else goto <D.22818>;
      <D.22817>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22812 = data[0];
        D.22819 = monoeg_g_strdup_printf ("ExportedType table row %d has invalid Flags %08x", i, D.22812);
        vinfo->info.message = D.22819;
        vinfo->exception_type = 3;
        D.22820 = ctx->errors;
        D.22821 = monoeg_g_slist_prepend (D.22820, vinfo);
        ctx->errors = D.22821;
      }
      <D.22818>:
      ctx->valid = 0;
      return;
      <D.22815>:
      D.22822 = data[2];
      D.22823 = is_valid_non_empty_string (ctx, D.22822);
      if (D.22823 == 0) goto <D.22824>; else goto <D.22825>;
      <D.22824>:
      D.22816 = ctx->report_error;
      if (D.22816 != 0) goto <D.22826>; else goto <D.22827>;
      <D.22826>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22828 = data[1];
        D.22829 = monoeg_g_strdup_printf ("ExportedType table row %d has invalid TypeName %08x", i, D.22828);
        vinfo->info.message = D.22829;
        vinfo->exception_type = 3;
        D.22820 = ctx->errors;
        D.22830 = monoeg_g_slist_prepend (D.22820, vinfo);
        ctx->errors = D.22830;
      }
      <D.22827>:
      ctx->valid = 0;
      return;
      <D.22825>:
      D.22831 = data[3];
      if (D.22831 != 0) goto <D.22832>; else goto <D.22833>;
      <D.22832>:
      D.22831 = data[3];
      D.22834 = is_valid_string (ctx, D.22831);
      if (D.22834 == 0) goto <D.22835>; else goto <D.22836>;
      <D.22835>:
      D.22816 = ctx->report_error;
      if (D.22816 != 0) goto <D.22837>; else goto <D.22838>;
      <D.22837>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22831 = data[3];
        D.22839 = monoeg_g_strdup_printf ("ExportedType table row %d has invalid TypeNamespace %08x", i, D.22831);
        vinfo->info.message = D.22839;
        vinfo->exception_type = 3;
        D.22820 = ctx->errors;
        D.22840 = monoeg_g_slist_prepend (D.22820, vinfo);
        ctx->errors = D.22840;
      }
      <D.22838>:
      ctx->valid = 0;
      return;
      <D.22836>:
      <D.22833>:
      D.22841 = data[4];
      D.22842 = is_valid_coded_index (ctx, 60, D.22841);
      if (D.22842 == 0) goto <D.22843>; else goto <D.22844>;
      <D.22843>:
      D.22816 = ctx->report_error;
      if (D.22816 != 0) goto <D.22845>; else goto <D.22846>;
      <D.22845>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22841 = data[4];
        D.22847 = monoeg_g_strdup_printf ("ExportedType table row %d has invalid Implementation token %08x", i, D.22841);
        vinfo->info.message = D.22847;
        vinfo->exception_type = 3;
        D.22820 = ctx->errors;
        D.22848 = monoeg_g_slist_prepend (D.22820, vinfo);
        ctx->errors = D.22848;
      }
      <D.22846>:
      ctx->valid = 0;
      return;
      <D.22844>:
      D.22841 = data[4];
      D.22849 = get_coded_index_token (60, D.22841);
      if (D.22849 == 0) goto <D.22850>; else goto <D.22851>;
      <D.22850>:
      D.22816 = ctx->report_error;
      if (D.22816 != 0) goto <D.22852>; else goto <D.22853>;
      <D.22852>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22854 = monoeg_g_strdup_printf ("ExportedType table row %d has null Implementation token", i);
        vinfo->info.message = D.22854;
        vinfo->exception_type = 3;
        D.22820 = ctx->errors;
        D.22855 = monoeg_g_slist_prepend (D.22820, vinfo);
        ctx->errors = D.22855;
      }
      <D.22853>:
      ctx->valid = 0;
      return;
      <D.22851>:
      D.22841 = data[4];
      D.22856 = get_coded_index_table (60, D.22841);
      if (D.22856 == 39) goto <D.22857>; else goto <D.22858>;
      <D.22857>:
      D.22831 = data[3];
      if (D.22831 != 0) goto <D.22859>; else goto <D.22860>;
      <D.22859>:
      D.22816 = ctx->report_error;
      if (D.22816 != 0) goto <D.22861>; else goto <D.22862>;
      <D.22861>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22863 = monoeg_g_strdup_printf ("ExportedType table row %d has denotes a nested type but has a non null TypeNamespace", i);
        vinfo->info.message = D.22863;
        vinfo->exception_type = 3;
        D.22820 = ctx->errors;
        D.22864 = monoeg_g_slist_prepend (D.22820, vinfo);
        ctx->errors = D.22864;
      }
      <D.22862>:
      ctx->valid = 0;
      return;
      <D.22860>:
      <D.22858>:
      i = i + 1;
      <D.18951>:
      D.22865 = table->rows;
      D.22866 = (int) D.22865;
      if (D.22866 > i) goto <D.18950>; else goto <D.18952>;
      <D.18952>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_manifest_resource_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22870;
  unsigned int D.22871;
  unsigned int D.22872;
  int D.22875;
  gchar * D.22878;
  struct GSList * D.22879;
  struct GSList * D.22880;
  unsigned int D.22881;
  gchar * D.22886;
  struct GSList * D.22887;
  unsigned int D.22888;
  int D.22889;
  gchar * D.22894;
  struct GSList * D.22895;
  unsigned int D.22896;
  int D.22897;
  gchar * D.22902;
  struct GSList * D.22903;
  unsigned int D.22908;
  gchar * D.22909;
  struct GSList * D.22910;
  _Bool D.22911;
  _Bool D.22912;
  _Bool D.22913;
  unsigned int D.22916;
  gchar * D.22921;
  struct GSList * D.22922;
  gchar * D.22929;
  struct GSList * D.22930;
  <unnamed-unsigned:24> D.22931;
  int D.22932;
  struct MonoCLIImageInfo * iinfo;
  struct MonoCLIHeader * ch;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 impl_table;
  guint32 token;
  guint32 resources_size;
  int i;

  try
    {
      D.22870 = ctx->image;
      iinfo = D.22870->image_info;
      ch = &iinfo->cli_cli_header;
      D.22870 = ctx->image;
      table = &D.22870->tables[40];
      resources_size = ch->ch_resources.size;
      i = 0;
      goto <D.18972>;
      <D.18971>:
      mono_metadata_decode_row (table, i, &data, 4);
      D.22871 = data[1];
      D.22872 = D.22871 & 4294967288;
      if (D.22872 != 0) goto <D.22873>; else goto <D.22874>;
      <D.22873>:
      D.22875 = ctx->report_error;
      if (D.22875 != 0) goto <D.22876>; else goto <D.22877>;
      <D.22876>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22871 = data[1];
        D.22878 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Flags %08x", i, D.22871);
        vinfo->info.message = D.22878;
        vinfo->exception_type = 3;
        D.22879 = ctx->errors;
        D.22880 = monoeg_g_slist_prepend (D.22879, vinfo);
        ctx->errors = D.22880;
      }
      <D.22877>:
      ctx->valid = 0;
      return;
      <D.22874>:
      D.22871 = data[1];
      D.22881 = D.22871 + 4294967295;
      if (D.22881 > 1) goto <D.22882>; else goto <D.22883>;
      <D.22882>:
      D.22875 = ctx->report_error;
      if (D.22875 != 0) goto <D.22884>; else goto <D.22885>;
      <D.22884>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22871 = data[1];
        D.22886 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Flags VisibilityMask %08x", i, D.22871);
        vinfo->info.message = D.22886;
        vinfo->exception_type = 3;
        D.22879 = ctx->errors;
        D.22887 = monoeg_g_slist_prepend (D.22879, vinfo);
        ctx->errors = D.22887;
      }
      <D.22885>:
      ctx->valid = 0;
      return;
      <D.22883>:
      D.22888 = data[2];
      D.22889 = is_valid_non_empty_string (ctx, D.22888);
      if (D.22889 == 0) goto <D.22890>; else goto <D.22891>;
      <D.22890>:
      D.22875 = ctx->report_error;
      if (D.22875 != 0) goto <D.22892>; else goto <D.22893>;
      <D.22892>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22888 = data[2];
        D.22894 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Name %08x", i, D.22888);
        vinfo->info.message = D.22894;
        vinfo->exception_type = 3;
        D.22879 = ctx->errors;
        D.22895 = monoeg_g_slist_prepend (D.22879, vinfo);
        ctx->errors = D.22895;
      }
      <D.22893>:
      ctx->valid = 0;
      return;
      <D.22891>:
      D.22896 = data[3];
      D.22897 = is_valid_coded_index (ctx, 60, D.22896);
      if (D.22897 == 0) goto <D.22898>; else goto <D.22899>;
      <D.22898>:
      D.22875 = ctx->report_error;
      if (D.22875 != 0) goto <D.22900>; else goto <D.22901>;
      <D.22900>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22896 = data[3];
        D.22902 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Implementation token %08x", i, D.22896);
        vinfo->info.message = D.22902;
        vinfo->exception_type = 3;
        D.22879 = ctx->errors;
        D.22903 = monoeg_g_slist_prepend (D.22879, vinfo);
        ctx->errors = D.22903;
      }
      <D.22901>:
      ctx->valid = 0;
      return;
      <D.22899>:
      D.22896 = data[3];
      impl_table = get_coded_index_table (60, D.22896);
      D.22896 = data[3];
      token = get_coded_index_token (60, D.22896);
      if (impl_table == 39) goto <D.22904>; else goto <D.22905>;
      <D.22904>:
      D.22875 = ctx->report_error;
      if (D.22875 != 0) goto <D.22906>; else goto <D.22907>;
      <D.22906>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22896 = data[3];
        D.22908 = get_coded_index_table (60, D.22896);
        D.22909 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Implementation token table %08x", i, D.22908);
        vinfo->info.message = D.22909;
        vinfo->exception_type = 3;
        D.22879 = ctx->errors;
        D.22910 = monoeg_g_slist_prepend (D.22879, vinfo);
        ctx->errors = D.22910;
      }
      <D.22907>:
      ctx->valid = 0;
      return;
      <D.22905>:
      D.22911 = impl_table == 38;
      D.22912 = token != 0;
      D.22913 = D.22911 & D.22912;
      if (D.22913 != 0) goto <D.22914>; else goto <D.22915>;
      <D.22914>:
      D.22916 = data[0];
      if (D.22916 != 0) goto <D.22917>; else goto <D.22918>;
      <D.22917>:
      D.22875 = ctx->report_error;
      if (D.22875 != 0) goto <D.22919>; else goto <D.22920>;
      <D.22919>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22921 = monoeg_g_strdup_printf ("ManifestResource table row %d points to a file but has non-zero offset", i);
        vinfo->info.message = D.22921;
        vinfo->exception_type = 3;
        D.22879 = ctx->errors;
        D.22922 = monoeg_g_slist_prepend (D.22879, vinfo);
        ctx->errors = D.22922;
      }
      <D.22920>:
      ctx->valid = 0;
      return;
      <D.22918>:
      <D.22915>:
      if (token == 0) goto <D.22923>; else goto <D.22924>;
      <D.22923>:
      D.22916 = data[0];
      if (D.22916 >= resources_size) goto <D.22925>; else goto <D.22926>;
      <D.22925>:
      D.22875 = ctx->report_error;
      if (D.22875 != 0) goto <D.22927>; else goto <D.22928>;
      <D.22927>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22916 = data[0];
        D.22929 = monoeg_g_strdup_printf ("ManifestResource table row %d invalid Offset field %08x ", i, D.22916);
        vinfo->info.message = D.22929;
        vinfo->exception_type = 3;
        D.22879 = ctx->errors;
        D.22930 = monoeg_g_slist_prepend (D.22879, vinfo);
        ctx->errors = D.22930;
      }
      <D.22928>:
      ctx->valid = 0;
      return;
      <D.22926>:
      <D.22924>:
      i = i + 1;
      <D.18972>:
      D.22931 = table->rows;
      D.22932 = (int) D.22931;
      if (D.22932 > i) goto <D.18971>; else goto <D.18973>;
      <D.18973>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_nested_class_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22936;
  unsigned int D.22939;
  <unnamed-unsigned:24> D.22941;
  unsigned int D.22942;
  int D.22943;
  gchar * D.22946;
  struct GSList * D.22947;
  struct GSList * D.22948;
  unsigned int D.22951;
  gchar * D.22955;
  struct GSList * D.22956;
  gchar * D.22961;
  struct GSList * D.22962;
  <unnamed-unsigned:24> D.22963;
  int D.22964;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.22936 = ctx->image;
      table = &D.22936->tables[41];
      i = 0;
      goto <D.18984>;
      <D.18983>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.22939 = data[0];
      if (D.22939 == 0) goto <D.22937>; else goto <D.22940>;
      <D.22940>:
      D.22939 = data[0];
      D.22936 = ctx->image;
      D.22941 = D.22936->tables[2].rows;
      D.22942 = (unsigned int) D.22941;
      if (D.22939 > D.22942) goto <D.22937>; else goto <D.22938>;
      <D.22937>:
      D.22943 = ctx->report_error;
      if (D.22943 != 0) goto <D.22944>; else goto <D.22945>;
      <D.22944>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22939 = data[0];
        D.22946 = monoeg_g_strdup_printf ("NestedClass table row %d has invalid NestedClass token %08x", i, D.22939);
        vinfo->info.message = D.22946;
        vinfo->exception_type = 3;
        D.22947 = ctx->errors;
        D.22948 = monoeg_g_slist_prepend (D.22947, vinfo);
        ctx->errors = D.22948;
      }
      <D.22945>:
      ctx->valid = 0;
      return;
      <D.22938>:
      D.22951 = data[1];
      if (D.22951 == 0) goto <D.22949>; else goto <D.22952>;
      <D.22952>:
      D.22951 = data[1];
      D.22936 = ctx->image;
      D.22941 = D.22936->tables[2].rows;
      D.22942 = (unsigned int) D.22941;
      if (D.22951 > D.22942) goto <D.22949>; else goto <D.22950>;
      <D.22949>:
      D.22943 = ctx->report_error;
      if (D.22943 != 0) goto <D.22953>; else goto <D.22954>;
      <D.22953>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22951 = data[1];
        D.22955 = monoeg_g_strdup_printf ("NestedClass table row %d has invalid EnclosingClass token %08x", i, D.22951);
        vinfo->info.message = D.22955;
        vinfo->exception_type = 3;
        D.22947 = ctx->errors;
        D.22956 = monoeg_g_slist_prepend (D.22947, vinfo);
        ctx->errors = D.22956;
      }
      <D.22954>:
      ctx->valid = 0;
      return;
      <D.22950>:
      D.22951 = data[1];
      D.22939 = data[0];
      if (D.22951 == D.22939) goto <D.22957>; else goto <D.22958>;
      <D.22957>:
      D.22943 = ctx->report_error;
      if (D.22943 != 0) goto <D.22959>; else goto <D.22960>;
      <D.22959>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22951 = data[1];
        D.22961 = monoeg_g_strdup_printf ("NestedClass table row %d has same token for NestedClass  and EnclosingClass %08x", i, D.22951);
        vinfo->info.message = D.22961;
        vinfo->exception_type = 3;
        D.22947 = ctx->errors;
        D.22962 = monoeg_g_slist_prepend (D.22947, vinfo);
        ctx->errors = D.22962;
      }
      <D.22960>:
      ctx->valid = 0;
      return;
      <D.22958>:
      i = i + 1;
      <D.18984>:
      D.22963 = table->rows;
      D.22964 = (int) D.22963;
      if (D.22964 > i) goto <D.18983>; else goto <D.18985>;
      <D.18985>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_generic_param_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22968;
  unsigned int D.22969;
  unsigned int D.22970;
  int D.22973;
  gchar * D.22976;
  struct GSList * D.22977;
  struct GSList * D.22978;
  unsigned int D.22979;
  gchar * D.22984;
  struct GSList * D.22985;
  unsigned int D.22986;
  int D.22987;
  gchar * D.22992;
  struct GSList * D.22993;
  int D.22994;
  gchar * D.22999;
  struct GSList * D.23000;
  unsigned int D.23001;
  gchar * D.23006;
  struct GSList * D.23007;
  unsigned int D.23010;
  unsigned int param_number.101;
  gchar * D.23016;
  struct GSList * D.23017;
  <unnamed-unsigned:24> D.23018;
  int D.23019;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 token;
  guint32 last_token;
  int i;
  int param_number;

  try
    {
      D.22968 = ctx->image;
      table = &D.22968->tables[42];
      last_token = 0;
      param_number = 0;
      i = 0;
      goto <D.19002>;
      <D.19001>:
      mono_metadata_decode_row (table, i, &data, 4);
      D.22969 = data[1];
      D.22970 = D.22969 & 4294967264;
      if (D.22970 != 0) goto <D.22971>; else goto <D.22972>;
      <D.22971>:
      D.22973 = ctx->report_error;
      if (D.22973 != 0) goto <D.22974>; else goto <D.22975>;
      <D.22974>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22969 = data[1];
        D.22976 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid Flags token %08x", i, D.22969);
        vinfo->info.message = D.22976;
        vinfo->exception_type = 3;
        D.22977 = ctx->errors;
        D.22978 = monoeg_g_slist_prepend (D.22977, vinfo);
        ctx->errors = D.22978;
      }
      <D.22975>:
      ctx->valid = 0;
      return;
      <D.22972>:
      D.22969 = data[1];
      D.22979 = D.22969 & 3;
      if (D.22979 == 3) goto <D.22980>; else goto <D.22981>;
      <D.22980>:
      D.22973 = ctx->report_error;
      if (D.22973 != 0) goto <D.22982>; else goto <D.22983>;
      <D.22982>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22984 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid VarianceMask 0x3", i);
        vinfo->info.message = D.22984;
        vinfo->exception_type = 3;
        D.22977 = ctx->errors;
        D.22985 = monoeg_g_slist_prepend (D.22977, vinfo);
        ctx->errors = D.22985;
      }
      <D.22983>:
      ctx->valid = 0;
      return;
      <D.22981>:
      D.22986 = data[3];
      D.22987 = is_valid_non_empty_string (ctx, D.22986);
      if (D.22987 == 0) goto <D.22988>; else goto <D.22989>;
      <D.22988>:
      D.22973 = ctx->report_error;
      if (D.22973 != 0) goto <D.22990>; else goto <D.22991>;
      <D.22990>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22986 = data[3];
        D.22992 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid Name token %08x", i, D.22986);
        vinfo->info.message = D.22992;
        vinfo->exception_type = 3;
        D.22977 = ctx->errors;
        D.22993 = monoeg_g_slist_prepend (D.22977, vinfo);
        ctx->errors = D.22993;
      }
      <D.22991>:
      ctx->valid = 0;
      return;
      <D.22989>:
      token = data[2];
      D.22994 = is_valid_coded_index (ctx, 78, token);
      if (D.22994 == 0) goto <D.22995>; else goto <D.22996>;
      <D.22995>:
      D.22973 = ctx->report_error;
      if (D.22973 != 0) goto <D.22997>; else goto <D.22998>;
      <D.22997>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22999 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid Owner token %08x", i, token);
        vinfo->info.message = D.22999;
        vinfo->exception_type = 3;
        D.22977 = ctx->errors;
        D.23000 = monoeg_g_slist_prepend (D.22977, vinfo);
        ctx->errors = D.23000;
      }
      <D.22998>:
      ctx->valid = 0;
      return;
      <D.22996>:
      D.23001 = get_coded_index_token (78, token);
      if (D.23001 == 0) goto <D.23002>; else goto <D.23003>;
      <D.23002>:
      D.22973 = ctx->report_error;
      if (D.22973 != 0) goto <D.23004>; else goto <D.23005>;
      <D.23004>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23006 = monoeg_g_strdup_printf ("GenericParam table row %d has null Owner token", i);
        vinfo->info.message = D.23006;
        vinfo->exception_type = 3;
        D.22977 = ctx->errors;
        D.23007 = monoeg_g_slist_prepend (D.22977, vinfo);
        ctx->errors = D.23007;
      }
      <D.23005>:
      ctx->valid = 0;
      return;
      <D.23003>:
      if (token != last_token) goto <D.23008>; else goto <D.23009>;
      <D.23008>:
      param_number = 0;
      last_token = token;
      <D.23009>:
      D.23010 = data[0];
      param_number.101 = (unsigned int) param_number;
      if (D.23010 != param_number.101) goto <D.23012>; else goto <D.23013>;
      <D.23012>:
      D.22973 = ctx->report_error;
      if (D.22973 != 0) goto <D.23014>; else goto <D.23015>;
      <D.23014>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23010 = data[0];
        D.23016 = monoeg_g_strdup_printf ("GenericParam table row %d Number is out of order %d expected %d", i, D.23010, param_number);
        vinfo->info.message = D.23016;
        vinfo->exception_type = 3;
        D.22977 = ctx->errors;
        D.23017 = monoeg_g_slist_prepend (D.22977, vinfo);
        ctx->errors = D.23017;
      }
      <D.23015>:
      ctx->valid = 0;
      return;
      <D.23013>:
      param_number = param_number + 1;
      i = i + 1;
      <D.19002>:
      D.23018 = table->rows;
      D.23019 = (int) D.23018;
      if (D.23019 > i) goto <D.19001>; else goto <D.19003>;
      <D.19003>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_method_spec_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23023;
  unsigned int D.23024;
  int D.23025;
  int D.23028;
  gchar * D.23031;
  struct GSList * D.23032;
  struct GSList * D.23033;
  unsigned int D.23034;
  gchar * D.23039;
  struct GSList * D.23040;
  unsigned int D.23041;
  int D.23044;
  gchar * D.23049;
  struct GSList * D.23050;
  <unnamed-unsigned:24> D.23051;
  int D.23052;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.23023 = ctx->image;
      table = &D.23023->tables[43];
      i = 0;
      goto <D.19014>;
      <D.19013>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.23024 = data[0];
      D.23025 = is_valid_coded_index (ctx, 52, D.23024);
      if (D.23025 == 0) goto <D.23026>; else goto <D.23027>;
      <D.23026>:
      D.23028 = ctx->report_error;
      if (D.23028 != 0) goto <D.23029>; else goto <D.23030>;
      <D.23029>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23024 = data[0];
        D.23031 = monoeg_g_strdup_printf ("MethodSpec table row %d has invalid Method token %08x", i, D.23024);
        vinfo->info.message = D.23031;
        vinfo->exception_type = 3;
        D.23032 = ctx->errors;
        D.23033 = monoeg_g_slist_prepend (D.23032, vinfo);
        ctx->errors = D.23033;
      }
      <D.23030>:
      ctx->valid = 0;
      return;
      <D.23027>:
      D.23024 = data[0];
      D.23034 = get_coded_index_token (52, D.23024);
      if (D.23034 == 0) goto <D.23035>; else goto <D.23036>;
      <D.23035>:
      D.23028 = ctx->report_error;
      if (D.23028 != 0) goto <D.23037>; else goto <D.23038>;
      <D.23037>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23039 = monoeg_g_strdup_printf ("MethodSpec table row %d has null Method token", i);
        vinfo->info.message = D.23039;
        vinfo->exception_type = 3;
        D.23032 = ctx->errors;
        D.23040 = monoeg_g_slist_prepend (D.23032, vinfo);
        ctx->errors = D.23040;
      }
      <D.23038>:
      ctx->valid = 0;
      return;
      <D.23036>:
      D.23041 = data[1];
      if (D.23041 != 0) goto <D.23042>; else goto <D.23043>;
      <D.23042>:
      D.23041 = data[1];
      D.23044 = is_valid_blob_object (ctx, D.23041, 1);
      if (D.23044 == 0) goto <D.23045>; else goto <D.23046>;
      <D.23045>:
      D.23028 = ctx->report_error;
      if (D.23028 != 0) goto <D.23047>; else goto <D.23048>;
      <D.23047>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23041 = data[1];
        D.23049 = monoeg_g_strdup_printf ("MethodSpec table row %d has invalid signature token %08x", i, D.23041);
        vinfo->info.message = D.23049;
        vinfo->exception_type = 3;
        D.23032 = ctx->errors;
        D.23050 = monoeg_g_slist_prepend (D.23032, vinfo);
        ctx->errors = D.23050;
      }
      <D.23048>:
      ctx->valid = 0;
      return;
      <D.23046>:
      <D.23043>:
      i = i + 1;
      <D.19014>:
      D.23051 = table->rows;
      D.23052 = (int) D.23051;
      if (D.23052 > i) goto <D.19013>; else goto <D.19015>;
      <D.19015>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_generic_param_constraint_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23056;
  unsigned int D.23059;
  <unnamed-unsigned:24> D.23061;
  unsigned int D.23062;
  int D.23063;
  gchar * D.23066;
  struct GSList * D.23067;
  struct GSList * D.23068;
  unsigned int D.23069;
  int D.23070;
  gchar * D.23075;
  struct GSList * D.23076;
  unsigned int D.23077;
  gchar * D.23082;
  struct GSList * D.23083;
  gchar * D.23088;
  struct GSList * D.23089;
  gchar * D.23096;
  struct GSList * D.23097;
  <unnamed-unsigned:24> D.23099;
  int D.23100;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;
  guint32 last_owner;
  guint32 last_constraint;

  try
    {
      D.23056 = ctx->image;
      table = &D.23056->tables[44];
      last_owner = 0;
      last_constraint = 0;
      i = 0;
      goto <D.19040>;
      <D.19039>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.23059 = data[0];
      if (D.23059 == 0) goto <D.23057>; else goto <D.23060>;
      <D.23060>:
      D.23059 = data[0];
      D.23056 = ctx->image;
      D.23061 = D.23056->tables[42].rows;
      D.23062 = (unsigned int) D.23061;
      if (D.23059 > D.23062) goto <D.23057>; else goto <D.23058>;
      <D.23057>:
      D.23063 = ctx->report_error;
      if (D.23063 != 0) goto <D.23064>; else goto <D.23065>;
      <D.23064>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23059 = data[0];
        D.23066 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d has invalid Owner token %08x", i, D.23059);
        vinfo->info.message = D.23066;
        vinfo->exception_type = 3;
        D.23067 = ctx->errors;
        D.23068 = monoeg_g_slist_prepend (D.23067, vinfo);
        ctx->errors = D.23068;
      }
      <D.23065>:
      ctx->valid = 0;
      return;
      <D.23058>:
      D.23069 = data[1];
      D.23070 = is_valid_coded_index (ctx, 0, D.23069);
      if (D.23070 == 0) goto <D.23071>; else goto <D.23072>;
      <D.23071>:
      D.23063 = ctx->report_error;
      if (D.23063 != 0) goto <D.23073>; else goto <D.23074>;
      <D.23073>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23069 = data[1];
        D.23075 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d has invalid Constraint token %08x", i, D.23069);
        vinfo->info.message = D.23075;
        vinfo->exception_type = 3;
        D.23067 = ctx->errors;
        D.23076 = monoeg_g_slist_prepend (D.23067, vinfo);
        ctx->errors = D.23076;
      }
      <D.23074>:
      ctx->valid = 0;
      return;
      <D.23072>:
      D.23069 = data[1];
      D.23077 = get_coded_index_token (0, D.23069);
      if (D.23077 == 0) goto <D.23078>; else goto <D.23079>;
      <D.23078>:
      D.23063 = ctx->report_error;
      if (D.23063 != 0) goto <D.23080>; else goto <D.23081>;
      <D.23080>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23082 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d has null Constraint token", i);
        vinfo->info.message = D.23082;
        vinfo->exception_type = 3;
        D.23067 = ctx->errors;
        D.23083 = monoeg_g_slist_prepend (D.23067, vinfo);
        ctx->errors = D.23083;
      }
      <D.23081>:
      ctx->valid = 0;
      return;
      <D.23079>:
      D.23059 = data[0];
      if (D.23059 < last_owner) goto <D.23084>; else goto <D.23085>;
      <D.23084>:
      D.23063 = ctx->report_error;
      if (D.23063 != 0) goto <D.23086>; else goto <D.23087>;
      <D.23086>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23059 = data[0];
        D.23088 = 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.23059);
        vinfo->info.message = D.23088;
        vinfo->exception_type = 3;
        D.23067 = ctx->errors;
        D.23089 = monoeg_g_slist_prepend (D.23067, vinfo);
        ctx->errors = D.23089;
      }
      <D.23087>:
      ctx->valid = 0;
      return;
      <D.23085>:
      D.23059 = data[0];
      if (D.23059 == last_owner) goto <D.23090>; else goto <D.23091>;
      <D.23090>:
      D.23069 = data[1];
      if (D.23069 == last_constraint) goto <D.23092>; else goto <D.23093>;
      <D.23092>:
      D.23063 = ctx->report_error;
      if (D.23063 != 0) goto <D.23094>; else goto <D.23095>;
      <D.23094>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23096 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d has duplicate constraint 0x%08x", i, last_constraint);
        vinfo->info.message = D.23096;
        vinfo->exception_type = 3;
        D.23067 = ctx->errors;
        D.23097 = monoeg_g_slist_prepend (D.23067, vinfo);
        ctx->errors = D.23097;
      }
      <D.23095>:
      ctx->valid = 0;
      return;
      <D.23093>:
      goto <D.23098>;
      <D.23091>:
      last_owner = data[0];
      <D.23098>:
      last_constraint = data[1];
      i = i + 1;
      <D.19040>:
      D.23099 = table->rows;
      D.23100 = (int) D.23099;
      if (D.23100 > i) goto <D.19039>; else goto <D.19041>;
      <D.19041>:
    }
  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.23104;
  unsigned int D.23105;
  const char * D.23106;
  unsigned int D.23107;
  const char * D.23108;
  unsigned int D.23109;
  unsigned int D.23110;
  int D.23113;
  unsigned int D.23114;
  _Bool D.23115;
  long int D.23116;
  long int D.23117;
  unsigned int D.23120;
  void * D.23121;
  int D.23124;
  unsigned int D.23127;
  const char * D.23128;
  const char * D.23129;
  gchar * D.23130;
  struct GSList * D.23131;
  struct GSList * D.23132;
  <unnamed-unsigned:24> D.23133;
  int D.23134;
  int i;
  guint32 data[6];
  guint32 nested_data[2];
  struct MonoTableInfo * table;
  struct MonoTableInfo * nested_table;
  struct GHashTable * unique_types;

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

        type = monoeg_malloc (12);
        mono_metadata_decode_row (table, i, &data, 6);
        D.23105 = data[1];
        D.23104 = ctx->image;
        D.23106 = mono_metadata_string_heap (D.23104, D.23105);
        type->name = D.23106;
        D.23107 = data[2];
        D.23104 = ctx->image;
        D.23108 = mono_metadata_string_heap (D.23104, D.23107);
        type->name_space = D.23108;
        type->resolution_scope = 0;
        D.23109 = data[0];
        visibility = D.23109 & 7;
        D.23110 = visibility + 4294967294;
        if (D.23110 <= 5) goto <D.23111>; else goto <D.23112>;
        <D.23111>:
        {
          int res;

          D.23113 = i + 1;
          D.23114 = (unsigned int) D.23113;
          res = search_sorted_table (ctx, 41, 0, D.23114);
          D.23115 = res < 0;
          D.23116 = (long int) D.23115;
          D.23117 = __builtin_expect (D.23116, 0);
          if (D.23117 != 0) goto <D.23118>; else goto <D.23119>;
          <D.23118>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 3700, "res >= 0");
          <D.23119>:
          mono_metadata_decode_row (nested_table, res, &nested_data, 2);
          D.23120 = nested_data[1];
          type->resolution_scope = D.23120;
        }
        <D.23112>:
        D.23121 = monoeg_g_hash_table_lookup (unique_types, type);
        if (D.23121 != 0B) goto <D.23122>; else goto <D.23123>;
        <D.23122>:
        D.23124 = ctx->report_error;
        if (D.23124 != 0) goto <D.23125>; else goto <D.23126>;
        <D.23125>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.23127 = type->resolution_scope;
          D.23128 = type->name_space;
          D.23129 = type->name;
          D.23130 = monoeg_g_strdup_printf ("TypeDef table row %d has duplicate for tuple (%s,%s,%x)", i, D.23129, D.23128, D.23127);
          vinfo->info.message = D.23130;
          vinfo->exception_type = 3;
          D.23131 = ctx->errors;
          D.23132 = monoeg_g_slist_prepend (D.23131, vinfo);
          ctx->errors = D.23132;
        }
        <D.23126>:
        ctx->valid = 0;
        monoeg_g_hash_table_destroy (unique_types);
        monoeg_g_free (type);
        return;
        <D.23123>:
        monoeg_g_hash_table_insert_replace (unique_types, type, 1B, 0);
      }
      i = i + 1;
      <D.19089>:
      D.23133 = table->rows;
      D.23134 = (int) D.23133;
      if (D.23134 > i) goto <D.19088>; else goto <D.19090>;
      <D.19090>:
      monoeg_g_hash_table_destroy (unique_types);
    }
  finally
    {
      data = {CLOBBER};
      nested_data = {CLOBBER};
    }
}


typedef_equals (const void * _a, const void * _b)
{
  gboolean D.23138;
  int iftmp.102;
  int D.19065;
  const char * D.23142;
  const char * D.23143;
  int D.19074;
  const char * D.23145;
  const char * D.23146;
  unsigned int D.23148;
  unsigned int D.23149;
  const struct TypeDefUniqueId * a;
  const struct TypeDefUniqueId * b;

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

    D.23142 = b->name;
    D.23143 = a->name;
    D.19065 = __builtin_strcmp (D.23143, D.23142);
  }
  if (D.19065 == 0) goto <D.23144>; else goto <D.23140>;
  <D.23144>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.23145 = b->name_space;
    D.23146 = a->name_space;
    D.19074 = __builtin_strcmp (D.23146, D.23145);
  }
  if (D.19074 == 0) goto <D.23147>; else goto <D.23140>;
  <D.23147>:
  D.23148 = a->resolution_scope;
  D.23149 = b->resolution_scope;
  if (D.23148 == D.23149) goto <D.23150>; else goto <D.23140>;
  <D.23150>:
  iftmp.102 = 1;
  goto <D.23141>;
  <D.23140>:
  iftmp.102 = 0;
  <D.23141>:
  D.23138 = iftmp.102;
  return D.23138;
}


typedef_hash (const void * _key)
{
  guint D.23152;
  const char * D.23153;
  unsigned int D.23154;
  const char * D.23155;
  unsigned int D.23156;
  unsigned int D.23157;
  unsigned int D.23158;
  const struct TypeDefUniqueId * key;

  key = _key;
  D.23153 = key->name;
  D.23154 = monoeg_g_str_hash (D.23153);
  D.23155 = key->name_space;
  D.23156 = monoeg_g_str_hash (D.23155);
  D.23157 = D.23154 ^ D.23156;
  D.23158 = key->resolution_scope;
  D.23152 = D.23157 ^ D.23158;
  return D.23152;
}


mono_verifier_verify_full_table_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.23160;
  gboolean D.23163;
  _Bool D.23164;
  int D.23165;
  int D.23166;
  struct VerifyContext ctx;
  void cleanup = <<< error >>>;

  try
    {
      D.23160 = mono_verifier_is_enabled_for_image (image);
      if (D.23160 == 0) goto <D.23161>; else goto <D.23162>;
      <D.23161>:
      D.23163 = 1;
      return D.23163;
      <D.23162>:
      D.23164 = error_list != 0B;
      D.23165 = (int) D.23164;
      init_verify_context (&ctx, image, D.23165);
      ctx.stage = 2;
      verify_typedef_table_full (&ctx);
      D.23166 = ctx.valid;
      if (D.23166 == 0) goto cleanup; else goto <D.23167>;
      <D.23167>:
      verify_field_table_full (&ctx);
      D.23166 = ctx.valid;
      if (D.23166 == 0) goto cleanup; else goto <D.23168>;
      <D.23168>:
      verify_method_table_full (&ctx);
      D.23166 = ctx.valid;
      if (D.23166 == 0) goto cleanup; else goto <D.23169>;
      <D.23169>:
      verify_memberref_table_full (&ctx);
      D.23166 = ctx.valid;
      if (D.23166 == 0) goto cleanup; else goto <D.23170>;
      <D.23170>:
      verify_cattr_table_full (&ctx);
      D.23166 = ctx.valid;
      if (D.23166 == 0) goto cleanup; else goto <D.23171>;
      <D.23171>:
      verify_field_marshal_table_full (&ctx);
      D.23166 = ctx.valid;
      if (D.23166 == 0) goto cleanup; else goto <D.23172>;
      <D.23172>:
      verify_decl_security_table_full (&ctx);
      D.23166 = ctx.valid;
      if (D.23166 == 0) goto cleanup; else goto <D.23173>;
      <D.23173>:
      verify_standalonesig_table_full (&ctx);
      D.23166 = ctx.valid;
      if (D.23166 == 0) goto cleanup; else goto <D.23174>;
      <D.23174>:
      verify_event_table_full (&ctx);
      D.23166 = ctx.valid;
      if (D.23166 == 0) goto cleanup; else goto <D.23175>;
      <D.23175>:
      verify_typespec_table_full (&ctx);
      D.23166 = ctx.valid;
      if (D.23166 == 0) goto cleanup; else goto <D.23176>;
      <D.23176>:
      verify_method_spec_table_full (&ctx);
      D.23166 = ctx.valid;
      if (D.23166 == 0) goto cleanup; else goto <D.23177>;
      <D.23177>:
      verify_tables_data_global_constraints_full (&ctx);
      cleanup:
      D.23163 = cleanup_context (&ctx, error_list);
      return D.23163;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


verify_typedef_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.23180;
  unsigned int D.23181;
  unsigned int D.23182;
  int D.23185;
  gchar * D.23188;
  struct GSList * D.23189;
  struct GSList * D.23190;
  unsigned int D.23193;
  unsigned int D.23194;
  unsigned int D.23197;
  gchar * D.23202;
  struct GSList * D.23203;
  unsigned int D.23205;
  _Bool D.23206;
  gchar * D.23213;
  struct GSList * D.23214;
  gchar * D.23220;
  struct GSList * D.23221;
  <unnamed-unsigned:24> D.23222;
  int D.23223;
  struct MonoTableInfo * table;
  guint32 data[6];
  int i;

  try
    {
      D.23180 = ctx->image;
      table = &D.23180->tables[2];
      D.23181 = BIT_FIELD_REF <*table, 32, 32>;
      D.23182 = D.23181 & 16777215;
      if (D.23182 == 0) goto <D.23183>; else goto <D.23184>;
      <D.23183>:
      D.23185 = ctx->report_error;
      if (D.23185 != 0) goto <D.23186>; else goto <D.23187>;
      <D.23186>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23188 = monoeg_g_strdup_printf ("Typedef table must have exactly at least one row");
        vinfo->info.message = D.23188;
        vinfo->exception_type = 3;
        D.23189 = ctx->errors;
        D.23190 = monoeg_g_slist_prepend (D.23189, vinfo);
        ctx->errors = D.23190;
      }
      <D.23187>:
      ctx->valid = 0;
      return;
      <D.23184>:
      i = 0;
      goto <D.18423>;
      <D.18422>:
      mono_metadata_decode_row (table, i, &data, 6);
      if (i == 0) goto <D.23191>; else goto <D.23192>;
      <D.23191>:
      // predicted unlikely by continue predictor.
      goto <D.18416>;
      <D.23192>:
      D.23193 = data[0];
      D.23194 = D.23193 & 32;
      if (D.23194 != 0) goto <D.23195>; else goto <D.23196>;
      <D.23195>:
      D.23197 = data[3];
      if (D.23197 != 0) goto <D.23198>; else goto <D.23199>;
      <D.23198>:
      D.23185 = ctx->report_error;
      if (D.23185 != 0) goto <D.23200>; else goto <D.23201>;
      <D.23200>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23202 = monoeg_g_strdup_printf ("Invalid typedef row %d for interface type must have a null extend field", i);
        vinfo->info.message = D.23202;
        vinfo->exception_type = 3;
        D.23189 = ctx->errors;
        D.23203 = monoeg_g_slist_prepend (D.23189, vinfo);
        ctx->errors = D.23203;
      }
      <D.23201>:
      ctx->valid = 0;
      return;
      <D.23199>:
      goto <D.23204>;
      <D.23196>:
      {
        gboolean is_sys_obj;
        gboolean has_parent;

        is_sys_obj = typedef_is_system_object (ctx, &data);
        D.23197 = data[3];
        D.23205 = get_coded_index_token (0, D.23197);
        D.23206 = D.23205 != 0;
        has_parent = (gboolean) D.23206;
        if (is_sys_obj != 0) goto <D.23207>; else goto <D.23208>;
        <D.23207>:
        if (has_parent != 0) goto <D.23209>; else goto <D.23210>;
        <D.23209>:
        D.23185 = ctx->report_error;
        if (D.23185 != 0) goto <D.23211>; else goto <D.23212>;
        <D.23211>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.23213 = monoeg_g_strdup_printf ("Invalid typedef row %d for System.Object must have a null extend field", i);
          vinfo->info.message = D.23213;
          vinfo->exception_type = 3;
          D.23189 = ctx->errors;
          D.23214 = monoeg_g_slist_prepend (D.23189, vinfo);
          ctx->errors = D.23214;
        }
        <D.23212>:
        ctx->valid = 0;
        return;
        <D.23210>:
        goto <D.23215>;
        <D.23208>:
        if (has_parent == 0) goto <D.23216>; else goto <D.23217>;
        <D.23216>:
        D.23185 = ctx->report_error;
        if (D.23185 != 0) goto <D.23218>; else goto <D.23219>;
        <D.23218>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.23220 = monoeg_g_strdup_printf ("Invalid typedef row %d for non-interface type must have a non-null extend field", i);
          vinfo->info.message = D.23220;
          vinfo->exception_type = 3;
          D.23189 = ctx->errors;
          D.23221 = monoeg_g_slist_prepend (D.23189, vinfo);
          ctx->errors = D.23221;
        }
        <D.23219>:
        ctx->valid = 0;
        return;
        <D.23217>:
        <D.23215>:
      }
      <D.23204>:
      <D.18416>:
      i = i + 1;
      <D.18423>:
      D.23222 = table->rows;
      D.23223 = (int) D.23222;
      if (D.23223 > i) goto <D.18422>; else goto <D.18424>;
      <D.18424>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


typedef_is_system_object (struct VerifyContext * ctx, guint32 * data)
{
  gboolean D.23227;
  int iftmp.103;
  struct MonoImage * D.23231;
  int D.23232;
  guint32 * D.23234;
  unsigned int D.23235;
  int D.23236;
  guint32 * D.23238;
  unsigned int D.23239;
  int D.23240;

  D.23231 = ctx->image;
  D.23232 = mono_verifier_is_corlib (D.23231);
  if (D.23232 != 0) goto <D.23233>; else goto <D.23229>;
  <D.23233>:
  D.23234 = data + 8;
  D.23235 = *D.23234;
  D.23236 = string_cmp (ctx, "System", D.23235);
  if (D.23236 == 0) goto <D.23237>; else goto <D.23229>;
  <D.23237>:
  D.23238 = data + 4;
  D.23239 = *D.23238;
  D.23240 = string_cmp (ctx, "Object", D.23239);
  if (D.23240 == 0) goto <D.23241>; else goto <D.23229>;
  <D.23241>:
  iftmp.103 = 1;
  goto <D.23230>;
  <D.23229>:
  iftmp.103 = 0;
  <D.23230>:
  D.23227 = iftmp.103;
  return D.23227;
}


mono_verifier_is_corlib (struct MonoImage * image)
{
  int iftmp.104;
  <unnamed type> D.23244;
  gboolean D.23248;
  int iftmp.105;
  const char * D.23253;
  int D.17801;
  int iftmp.106;
  int D.17797;
  const char[13] * D.23258;
  unsigned char D.23259;
  int D.23260;
  unsigned char D.23261;
  int D.23262;
  _Bool D.23263;
  _Bool D.23264;
  _Bool D.23265;
  const unsigned char * D.23268;
  unsigned char D.23269;
  int D.23270;
  const unsigned char * D.23271;
  unsigned char D.23272;
  int D.23273;
  _Bool D.23274;
  _Bool D.23275;
  const unsigned char * D.23278;
  unsigned char D.23279;
  int D.23280;
  const unsigned char * D.23281;
  unsigned char D.23282;
  int D.23283;
  _Bool D.23284;
  _Bool D.23285;
  const unsigned char * D.23288;
  unsigned char D.23289;
  int D.23290;
  const unsigned char * D.23291;
  unsigned char D.23292;
  int D.23293;
  gboolean trusted_location;

  D.23244 = mono_security_get_mode ();
  if (D.23244 == 1) goto <D.23245>; else goto <D.23246>;
  <D.23245>:
  iftmp.104 = mono_security_core_clr_is_platform_image (image);
  goto <D.23247>;
  <D.23246>:
  iftmp.104 = 1;
  <D.23247>:
  trusted_location = iftmp.104;
  if (trusted_location != 0) goto <D.23252>; else goto <D.23250>;
  <D.23252>:
  D.23253 = image->module_name;
  if (D.23253 != 0B) goto <D.23254>; else goto <D.23250>;
  <D.23254>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = image->module_name;
      D.23258 = "mscorlib.dll";
      D.23259 = MEM[(const unsigned char *)D.23258];
      D.23260 = (int) D.23259;
      D.23261 = *__s2;
      D.23262 = (int) D.23261;
      __result = D.23260 - D.23262;
      {
        D.23263 = __s1_len != 0;
        D.23264 = __result == 0;
        D.23265 = D.23263 & D.23264;
        if (D.23265 != 0) goto <D.23266>; else goto <D.23267>;
        <D.23266>:
        D.23268 = &MEM[(void *)"mscorlib.dll" + 1B];
        D.23269 = *D.23268;
        D.23270 = (int) D.23269;
        D.23271 = __s2 + 1;
        D.23272 = *D.23271;
        D.23273 = (int) D.23272;
        __result = D.23270 - D.23273;
        D.23274 = __s1_len > 1;
        D.23264 = __result == 0;
        D.23275 = D.23274 & D.23264;
        if (D.23275 != 0) goto <D.23276>; else goto <D.23277>;
        <D.23276>:
        D.23278 = &MEM[(void *)"mscorlib.dll" + 2B];
        D.23279 = *D.23278;
        D.23280 = (int) D.23279;
        D.23281 = __s2 + 2;
        D.23282 = *D.23281;
        D.23283 = (int) D.23282;
        __result = D.23280 - D.23283;
        D.23284 = __s1_len > 2;
        D.23264 = __result == 0;
        D.23285 = D.23284 & D.23264;
        if (D.23285 != 0) goto <D.23286>; else goto <D.23287>;
        <D.23286>:
        D.23288 = &MEM[(void *)"mscorlib.dll" + 3B];
        D.23289 = *D.23288;
        D.23290 = (int) D.23289;
        D.23291 = __s2 + 3;
        D.23292 = *D.23291;
        D.23293 = (int) D.23292;
        __result = D.23290 - D.23293;
        <D.23287>:
        <D.23277>:
        <D.23267>:
      }
      D.17797 = __result;
    }
    iftmp.106 = D.17797;
    goto <D.23294>;
    <D.23257>:
    D.23253 = image->module_name;
    iftmp.106 = __builtin_strcmp ("mscorlib.dll", D.23253);
    <D.23294>:
    D.17801 = iftmp.106;
  }
  if (D.17801 == 0) goto <D.23295>; else goto <D.23250>;
  <D.23295>:
  iftmp.105 = 1;
  goto <D.23251>;
  <D.23250>:
  iftmp.105 = 0;
  <D.23251>:
  D.23248 = iftmp.105;
  return D.23248;
}


string_cmp (struct VerifyContext * ctx, const char * str, guint offset)
{
  int D.23299;
  int D.17779;
  int iftmp.107;
  int D.17778;
  const char[1] * D.23303;
  unsigned char D.23304;
  int D.23305;
  unsigned char D.23306;
  int D.23307;
  _Bool D.23308;
  _Bool D.23309;
  _Bool D.23310;
  const unsigned char * D.23313;
  unsigned char D.23314;
  int D.23315;
  const unsigned char * D.23316;
  unsigned char D.23317;
  int D.23318;
  _Bool D.23319;
  _Bool D.23320;
  const unsigned char * D.23323;
  unsigned char D.23324;
  int D.23325;
  const unsigned char * D.23326;
  unsigned char D.23327;
  int D.23328;
  _Bool D.23329;
  _Bool D.23330;
  const unsigned char * D.23333;
  unsigned char D.23334;
  int D.23335;
  const unsigned char * D.23336;
  unsigned char D.23337;
  int D.23338;
  unsigned char D.23340;
  int D.17788;
  const char * D.23341;

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

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

      __s2 = str;
      D.23303 = "";
      D.23304 = MEM[(const unsigned char *)D.23303];
      D.23305 = (int) D.23304;
      D.23306 = *__s2;
      D.23307 = (int) D.23306;
      __result = D.23305 - D.23307;
      {
        D.23308 = __s2_len != 0;
        D.23309 = __result == 0;
        D.23310 = D.23308 & D.23309;
        if (D.23310 != 0) goto <D.23311>; else goto <D.23312>;
        <D.23311>:
        D.23313 = &MEM[(void *)"" + 1B];
        D.23314 = *D.23313;
        D.23315 = (int) D.23314;
        D.23316 = __s2 + 1;
        D.23317 = *D.23316;
        D.23318 = (int) D.23317;
        __result = D.23315 - D.23318;
        D.23319 = __s2_len > 1;
        D.23309 = __result == 0;
        D.23320 = D.23319 & D.23309;
        if (D.23320 != 0) goto <D.23321>; else goto <D.23322>;
        <D.23321>:
        D.23323 = &MEM[(void *)"" + 2B];
        D.23324 = *D.23323;
        D.23325 = (int) D.23324;
        D.23326 = __s2 + 2;
        D.23327 = *D.23326;
        D.23328 = (int) D.23327;
        __result = D.23325 - D.23328;
        D.23329 = __s2_len > 2;
        D.23309 = __result == 0;
        D.23330 = D.23329 & D.23309;
        if (D.23330 != 0) goto <D.23331>; else goto <D.23332>;
        <D.23331>:
        D.23333 = &MEM[(void *)"" + 3B];
        D.23334 = *D.23333;
        D.23335 = (int) D.23334;
        D.23336 = __s2 + 3;
        D.23337 = *D.23336;
        D.23338 = (int) D.23337;
        __result = D.23335 - D.23338;
        <D.23332>:
        <D.23322>:
        <D.23312>:
      }
      D.17778 = __result;
    }
    iftmp.107 = -D.17778;
    goto <D.23339>;
    <D.23302>:
    D.23340 = MEM[(const unsigned char * {ref-all})str];
    iftmp.107 = (int) D.23340;
    <D.23339>:
    D.17779 = iftmp.107;
  }
  D.23299 = D.17779;
  return D.23299;
  <D.23298>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.23341 = get_string_ptr (ctx, offset);
    D.17788 = __builtin_strcmp (str, D.23341);
  }
  D.23299 = D.17788;
  return D.23299;
}


verify_field_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.23343;
  unsigned int D.23346;
  int D.23348;
  int D.23349;
  gchar * D.23352;
  struct GSList * D.23353;
  struct GSList * D.23354;
  <unnamed-unsigned:24> D.23355;
  int D.23356;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.23343 = ctx->image;
      table = &D.23343->tables[4];
      i = 0;
      goto <D.18459>;
      <D.18458>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.23346 = data[2];
      if (D.23346 == 0) goto <D.23344>; else goto <D.23347>;
      <D.23347>:
      D.23346 = data[2];
      D.23348 = is_valid_field_signature (ctx, D.23346);
      if (D.23348 == 0) goto <D.23344>; else goto <D.23345>;
      <D.23344>:
      D.23349 = ctx->report_error;
      if (D.23349 != 0) goto <D.23350>; else goto <D.23351>;
      <D.23350>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23346 = data[2];
        D.23352 = monoeg_g_strdup_printf ("Invalid field row %d invalid signature token %08x", i, D.23346);
        vinfo->info.message = D.23352;
        vinfo->exception_type = 3;
        D.23353 = ctx->errors;
        D.23354 = monoeg_g_slist_prepend (D.23353, vinfo);
        ctx->errors = D.23354;
      }
      <D.23351>:
      ctx->valid = 0;
      return;
      <D.23345>:
      i = i + 1;
      <D.18459>:
      D.23355 = table->rows;
      D.23356 = (int) D.23355;
      if (D.23356 > i) goto <D.18458>; else goto <D.18460>;
      <D.18460>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_field_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.23360;
  int D.23363;
  gchar * D.23366;
  struct GSList * D.23367;
  struct GSList * D.23368;
  gboolean D.23369;
  const char * ptr.108;
  unsigned int size.109;
  int D.23372;
  gchar * D.23377;
  struct GSList * D.23378;
  unsigned int signature.110;
  gchar * D.23384;
  struct GSList * D.23385;
  const char * ptr.111;
  guint32 size;
  unsigned int signature;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      signature = 0;
      ptr = 0B;
      D.23360 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.23360 == 0) goto <D.23361>; else goto <D.23362>;
      <D.23361>:
      D.23363 = ctx->report_error;
      if (D.23363 != 0) goto <D.23364>; else goto <D.23365>;
      <D.23364>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23366 = monoeg_strdup ("FieldSig: Could not decode signature header");
        vinfo->info.message = D.23366;
        vinfo->exception_type = 3;
        D.23367 = ctx->errors;
        D.23368 = monoeg_g_slist_prepend (D.23367, vinfo);
        ctx->errors = D.23368;
      }
      <D.23365>:
      ctx->valid = 0;
      D.23369 = 0;
      return D.23369;
      <D.23362>:
      ptr.108 = ptr;
      size.109 = size;
      end = ptr.108 + size.109;
      D.23372 = safe_read (&ptr, end, &signature, 1);
      if (D.23372 == 0) goto <D.23373>; else goto <D.23374>;
      <D.23373>:
      D.23363 = ctx->report_error;
      if (D.23363 != 0) goto <D.23375>; else goto <D.23376>;
      <D.23375>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23377 = monoeg_strdup ("FieldSig: Not enough room for the signature");
        vinfo->info.message = D.23377;
        vinfo->exception_type = 3;
        D.23367 = ctx->errors;
        D.23378 = monoeg_g_slist_prepend (D.23367, vinfo);
        ctx->errors = D.23378;
      }
      <D.23376>:
      ctx->valid = 0;
      D.23369 = 0;
      return D.23369;
      <D.23374>:
      signature.110 = signature;
      if (signature.110 != 6) goto <D.23380>; else goto <D.23381>;
      <D.23380>:
      D.23363 = ctx->report_error;
      if (D.23363 != 0) goto <D.23382>; else goto <D.23383>;
      <D.23382>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        signature.110 = signature;
        D.23384 = monoeg_g_strdup_printf ("FieldSig: Invalid signature %x", signature.110);
        vinfo->info.message = D.23384;
        vinfo->exception_type = 3;
        D.23367 = ctx->errors;
        D.23385 = monoeg_g_slist_prepend (D.23367, vinfo);
        ctx->errors = D.23385;
      }
      <D.23383>:
      ctx->valid = 0;
      D.23369 = 0;
      return D.23369;
      <D.23381>:
      ptr.108 = ptr;
      ptr.111 = ptr.108 + 4294967295;
      ptr = ptr.111;
      D.23369 = parse_field (ctx, &ptr, end);
      return D.23369;
    }
  finally
    {
      size = {CLOBBER};
      signature = {CLOBBER};
      ptr = {CLOBBER};
    }
}


parse_field (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.112;
  int D.23390;
  int D.23393;
  gchar * D.23396;
  struct GSList * D.23397;
  struct GSList * D.23398;
  gboolean D.23399;
  unsigned int signature.113;
  gchar * D.23405;
  struct GSList * D.23406;
  int D.23407;
  int D.23410;
  const char * ptr.114;
  const char * ptr.115;
  const char * ptr;
  unsigned int signature;

  try
    {
      ptr.112 = *_ptr;
      ptr = ptr.112;
      signature = 0;
      D.23390 = safe_read (&ptr, end, &signature, 1);
      if (D.23390 == 0) goto <D.23391>; else goto <D.23392>;
      <D.23391>:
      D.23393 = ctx->report_error;
      if (D.23393 != 0) goto <D.23394>; else goto <D.23395>;
      <D.23394>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23396 = monoeg_strdup ("Field: Not enough room for field signature");
        vinfo->info.message = D.23396;
        vinfo->exception_type = 3;
        D.23397 = ctx->errors;
        D.23398 = monoeg_g_slist_prepend (D.23397, vinfo);
        ctx->errors = D.23398;
      }
      <D.23395>:
      ctx->valid = 0;
      D.23399 = 0;
      return D.23399;
      <D.23392>:
      signature.113 = signature;
      if (signature.113 != 6) goto <D.23401>; else goto <D.23402>;
      <D.23401>:
      D.23393 = ctx->report_error;
      if (D.23393 != 0) goto <D.23403>; else goto <D.23404>;
      <D.23403>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        signature.113 = signature;
        D.23405 = monoeg_g_strdup_printf ("Field: Invalid signature 0x%x, must be 6", signature.113);
        vinfo->info.message = D.23405;
        vinfo->exception_type = 3;
        D.23397 = ctx->errors;
        D.23406 = monoeg_g_slist_prepend (D.23397, vinfo);
        ctx->errors = D.23406;
      }
      <D.23404>:
      ctx->valid = 0;
      D.23399 = 0;
      return D.23399;
      <D.23402>:
      D.23407 = parse_custom_mods (ctx, &ptr, end);
      if (D.23407 == 0) goto <D.23408>; else goto <D.23409>;
      <D.23408>:
      D.23399 = 0;
      return D.23399;
      <D.23409>:
      D.23410 = safe_read (&ptr, end, &signature, 1);
      if (D.23410 != 0) goto <D.23411>; else goto <D.23412>;
      <D.23411>:
      signature.113 = signature;
      if (signature.113 != 16) goto <D.23413>; else goto <D.23414>;
      <D.23413>:
      ptr.114 = ptr;
      ptr.115 = ptr.114 + 4294967295;
      ptr = ptr.115;
      <D.23414>:
      <D.23412>:
      ptr.114 = ptr;
      *_ptr = ptr.114;
      D.23399 = parse_type (ctx, _ptr, end);
      return D.23399;
    }
  finally
    {
      ptr = {CLOBBER};
      signature = {CLOBBER};
    }
}


verify_method_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.23419;
  unsigned int D.23422;
  int D.23424;
  int D.23425;
  gchar * D.23428;
  struct GSList * D.23429;
  struct GSList * D.23430;
  int D.23433;
  gchar * D.23438;
  struct GSList * D.23439;
  <unnamed-unsigned:24> D.23440;
  int D.23441;
  struct MonoTableInfo * table;
  guint32 data[6];
  guint32 rva;
  guint32 locals_token;
  int i;

  try
    {
      D.23419 = ctx->image;
      table = &D.23419->tables[6];
      i = 0;
      goto <D.18539>;
      <D.18538>:
      mono_metadata_decode_row (table, i, &data, 6);
      rva = data[0];
      D.23422 = data[4];
      if (D.23422 == 0) goto <D.23420>; else goto <D.23423>;
      <D.23423>:
      D.23422 = data[4];
      D.23424 = is_valid_method_signature (ctx, D.23422);
      if (D.23424 == 0) goto <D.23420>; else goto <D.23421>;
      <D.23420>:
      D.23425 = ctx->report_error;
      if (D.23425 != 0) goto <D.23426>; else goto <D.23427>;
      <D.23426>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23422 = data[4];
        D.23428 = monoeg_g_strdup_printf ("Invalid method row %d invalid signature token 0x%08x", i, D.23422);
        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.23421>:
      if (rva != 0) goto <D.23431>; else goto <D.23432>;
      <D.23431>:
      D.23433 = is_valid_method_header (ctx, rva, &locals_token);
      if (D.23433 == 0) goto <D.23434>; else goto <D.23435>;
      <D.23434>:
      D.23425 = ctx->report_error;
      if (D.23425 != 0) goto <D.23436>; else goto <D.23437>;
      <D.23436>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23438 = monoeg_g_strdup_printf ("Invalid method row %d RVA points to an invalid method header", i);
        vinfo->info.message = D.23438;
        vinfo->exception_type = 3;
        D.23429 = ctx->errors;
        D.23439 = monoeg_g_slist_prepend (D.23429, vinfo);
        ctx->errors = D.23439;
      }
      <D.23437>:
      ctx->valid = 0;
      return;
      <D.23435>:
      <D.23432>:
      i = i + 1;
      <D.18539>:
      D.23440 = table->rows;
      D.23441 = (int) D.23440;
      if (D.23441 > i) goto <D.18538>; else goto <D.18540>;
      <D.18540>:
    }
  finally
    {
      data = {CLOBBER};
      locals_token = {CLOBBER};
    }
}


is_valid_method_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.23445;
  int D.23448;
  gchar * D.23451;
  struct GSList * D.23452;
  struct GSList * D.23453;
  gboolean D.23454;
  const char * ptr.116;
  unsigned int size.117;
  guint32 size;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      ptr = 0B;
      D.23445 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.23445 == 0) goto <D.23446>; else goto <D.23447>;
      <D.23446>:
      D.23448 = ctx->report_error;
      if (D.23448 != 0) goto <D.23449>; else goto <D.23450>;
      <D.23449>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23451 = monoeg_strdup ("MethodSig: Could not decode signature header");
        vinfo->info.message = D.23451;
        vinfo->exception_type = 3;
        D.23452 = ctx->errors;
        D.23453 = monoeg_g_slist_prepend (D.23452, vinfo);
        ctx->errors = D.23453;
      }
      <D.23450>:
      ctx->valid = 0;
      D.23454 = 0;
      return D.23454;
      <D.23447>:
      ptr.116 = ptr;
      size.117 = size;
      end = ptr.116 + size.117;
      D.23454 = parse_method_signature (ctx, &ptr, end, 0, 0);
      return D.23454;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


is_valid_method_header (struct VerifyContext * ctx, guint32 rva, guint32 * locals_token)
{
  struct MonoImage * D.23459;
  int D.23462;
  gchar * D.23465;
  struct GSList * D.23466;
  struct GSList * D.23467;
  gboolean D.23468;
  const char * D.23469;
  const char * ptr.118;
  unsigned int D.23471;
  int D.23472;
  gchar * D.23477;
  struct GSList * D.23478;
  unsigned int header.119;
  unsigned int D.23480;
  gchar * D.23483;
  struct GSList * D.23484;
  unsigned int header.120;
  const char * ptr.121;
  const char * D.23489;
  unsigned int D.23491;
  unsigned int ptr.122;
  int end.123;
  int ptr.124;
  int D.23497;
  gchar * D.23498;
  struct GSList * D.23499;
  const char * ptr.125;
  int D.23502;
  gchar * D.23507;
  struct GSList * D.23508;
  unsigned int fat_header.126;
  unsigned int D.23510;
  gchar * D.23515;
  struct GSList * D.23516;
  int D.23517;
  gchar * D.23522;
  struct GSList * D.23523;
  int D.23524;
  gchar * D.23529;
  struct GSList * D.23530;
  int D.23531;
  gchar * D.23536;
  struct GSList * D.23537;
  unsigned int local_vars_tok.127;
  unsigned int D.23541;
  gchar * D.23546;
  struct GSList * D.23547;
  unsigned int D.23548;
  <unnamed-unsigned:24> D.23549;
  unsigned int D.23550;
  gchar * D.23555;
  struct GSList * D.23556;
  gchar * D.23561;
  struct GSList * D.23562;
  unsigned int D.23563;
  gchar * D.23568;
  struct GSList * D.23569;
  unsigned int code_size.128;
  const char * ptr.129;
  unsigned int D.23575;
  gchar * D.23578;
  struct GSList * D.23579;
  unsigned int D.23580;
  const char * ptr.130;
  int D.23584;
  gchar * D.23589;
  struct GSList * D.23590;
  unsigned int section_header.131;
  unsigned int D.23592;
  gchar * D.23597;
  struct GSList * D.23598;
  unsigned int D.23599;
  _Bool D.23600;
  unsigned int D.23601;
  unsigned int iftmp.132;
  gchar * D.23610;
  struct GSList * D.23611;
  sizetype D.23614;
  const char * D.23615;
  unsigned int D.23617;
  unsigned int D.23618;
  gchar * D.23621;
  struct GSList * D.23622;
  unsigned int D.23623;
  unsigned int iftmp.133;
  guint32 iftmp.134;
  unsigned int D.23634;
  guint32 iftmp.135;
  unsigned int D.23641;
  unsigned int D.23642;
  guint32 iftmp.136;
  unsigned int D.23651;
  gchar * D.23652;
  struct GSList * D.23653;
  unsigned char D.23654;
  sizetype iftmp.137;
  const char * ptr.138;
  int D.23660;
  gchar * D.23665;
  struct GSList * D.23666;
  unsigned int class_token.139;
  unsigned int D.23672;
  _Bool D.23673;
  _Bool D.23674;
  _Bool D.23675;
  gchar * D.23680;
  struct GSList * D.23681;
  unsigned int D.23682;
  <unnamed-unsigned:24> D.23683;
  unsigned int D.23684;
  gchar * D.23689;
  struct GSList * D.23690;
  unsigned int D.23691;
  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.23459 = ctx->image;
      offset = mono_cli_rva_image_map (D.23459, rva);
      header = 0;
      fat_header = 0;
      size = 0;
      ptr = 0B;
      *locals_token = 0;
      if (offset == 4294967295) goto <D.23460>; else goto <D.23461>;
      <D.23460>:
      D.23462 = ctx->report_error;
      if (D.23462 != 0) goto <D.23463>; else goto <D.23464>;
      <D.23463>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23465 = monoeg_strdup ("MethodHeader: Invalid RVA");
        vinfo->info.message = D.23465;
        vinfo->exception_type = 3;
        D.23466 = ctx->errors;
        D.23467 = monoeg_g_slist_prepend (D.23466, vinfo);
        ctx->errors = D.23467;
      }
      <D.23464>:
      ctx->valid = 0;
      D.23468 = 0;
      return D.23468;
      <D.23461>:
      D.23469 = ctx->data;
      ptr.118 = D.23469 + offset;
      ptr = ptr.118;
      D.23469 = ctx->data;
      D.23471 = ctx->size;
      end = D.23469 + D.23471;
      D.23472 = safe_read (&ptr, end, &header, 1);
      if (D.23472 == 0) goto <D.23473>; else goto <D.23474>;
      <D.23473>:
      D.23462 = ctx->report_error;
      if (D.23462 != 0) goto <D.23475>; else goto <D.23476>;
      <D.23475>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23477 = monoeg_strdup ("MethodHeader: Not enough room for header");
        vinfo->info.message = D.23477;
        vinfo->exception_type = 3;
        D.23466 = ctx->errors;
        D.23478 = monoeg_g_slist_prepend (D.23466, vinfo);
        ctx->errors = D.23478;
      }
      <D.23476>:
      ctx->valid = 0;
      D.23468 = 0;
      return D.23468;
      <D.23474>:
      header.119 = header;
      D.23480 = header.119 & 3;
      switch (D.23480) <default: <D.23500>, case 0: <D.18325>, case 1: <D.18326>, case 2: <D.18328>>
      <D.18325>:
      <D.18326>:
      D.23462 = ctx->report_error;
      if (D.23462 != 0) goto <D.23481>; else goto <D.23482>;
      <D.23481>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        header.119 = header;
        D.23480 = header.119 & 3;
        D.23483 = monoeg_g_strdup_printf ("MethodHeader: Invalid header type 0x%x", D.23480);
        vinfo->info.message = D.23483;
        vinfo->exception_type = 3;
        D.23466 = ctx->errors;
        D.23484 = monoeg_g_slist_prepend (D.23466, vinfo);
        ctx->errors = D.23484;
      }
      <D.23482>:
      ctx->valid = 0;
      D.23468 = 0;
      return D.23468;
      <D.18328>:
      header.119 = header;
      header.120 = header.119 >> 2;
      header = header.120;
      ptr.121 = ptr;
      header.119 = header;
      D.23489 = ptr.121 + header.119;
      if (D.23489 > end) goto <D.23486>; else goto <D.23490>;
      <D.23490>:
      header.119 = header;
      D.23491 = ~header.119;
      ptr.121 = ptr;
      ptr.122 = (unsigned int) ptr.121;
      if (D.23491 < ptr.122) goto <D.23486>; else goto <D.23487>;
      <D.23486>:
      D.23462 = ctx->report_error;
      if (D.23462 != 0) goto <D.23493>; else goto <D.23494>;
      <D.23493>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        end.123 = (int) end;
        ptr.121 = ptr;
        ptr.124 = (int) ptr.121;
        D.23497 = end.123 - ptr.124;
        header.119 = header;
        D.23498 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for method body. Required %d, but only %d is available", header.119, D.23497);
        vinfo->info.message = D.23498;
        vinfo->exception_type = 3;
        D.23466 = ctx->errors;
        D.23499 = monoeg_g_slist_prepend (D.23466, vinfo);
        ctx->errors = D.23499;
      }
      <D.23494>:
      ctx->valid = 0;
      D.23468 = 0;
      return D.23468;
      <D.23487>:
      D.23468 = 1;
      return D.23468;
      <D.23500>:
      ptr.121 = ptr;
      ptr.125 = ptr.121 + 4294967295;
      ptr = ptr.125;
      D.23502 = safe_read (&ptr, end, &fat_header, 2);
      if (D.23502 == 0) goto <D.23503>; else goto <D.23504>;
      <D.23503>:
      D.23462 = ctx->report_error;
      if (D.23462 != 0) goto <D.23505>; else goto <D.23506>;
      <D.23505>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23507 = monoeg_strdup ("MethodHeader: Not enough room for fat header");
        vinfo->info.message = D.23507;
        vinfo->exception_type = 3;
        D.23466 = ctx->errors;
        D.23508 = monoeg_g_slist_prepend (D.23466, vinfo);
        ctx->errors = D.23508;
      }
      <D.23506>:
      ctx->valid = 0;
      D.23468 = 0;
      return D.23468;
      <D.23504>:
      fat_header.126 = fat_header;
      D.23510 = fat_header.126 >> 12;
      size = D.23510 & 15;
      if (size != 3) goto <D.23511>; else goto <D.23512>;
      <D.23511>:
      D.23462 = ctx->report_error;
      if (D.23462 != 0) goto <D.23513>; else goto <D.23514>;
      <D.23513>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23515 = monoeg_strdup ("MethodHeader: header size must be 3");
        vinfo->info.message = D.23515;
        vinfo->exception_type = 3;
        D.23466 = ctx->errors;
        D.23516 = monoeg_g_slist_prepend (D.23466, vinfo);
        ctx->errors = D.23516;
      }
      <D.23514>:
      ctx->valid = 0;
      D.23468 = 0;
      return D.23468;
      <D.23512>:
      D.23517 = safe_read (&ptr, end, &max_stack, 2);
      if (D.23517 == 0) goto <D.23518>; else goto <D.23519>;
      <D.23518>:
      D.23462 = ctx->report_error;
      if (D.23462 != 0) goto <D.23520>; else goto <D.23521>;
      <D.23520>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23522 = monoeg_strdup ("MethodHeader: Not enough room for max stack");
        vinfo->info.message = D.23522;
        vinfo->exception_type = 3;
        D.23466 = ctx->errors;
        D.23523 = monoeg_g_slist_prepend (D.23466, vinfo);
        ctx->errors = D.23523;
      }
      <D.23521>:
      ctx->valid = 0;
      D.23468 = 0;
      return D.23468;
      <D.23519>:
      D.23524 = safe_read (&ptr, end, &code_size, 4);
      if (D.23524 == 0) goto <D.23525>; else goto <D.23526>;
      <D.23525>:
      D.23462 = ctx->report_error;
      if (D.23462 != 0) goto <D.23527>; else goto <D.23528>;
      <D.23527>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23529 = monoeg_strdup ("MethodHeader: Not enough room for code size");
        vinfo->info.message = D.23529;
        vinfo->exception_type = 3;
        D.23466 = ctx->errors;
        D.23530 = monoeg_g_slist_prepend (D.23466, vinfo);
        ctx->errors = D.23530;
      }
      <D.23528>:
      ctx->valid = 0;
      D.23468 = 0;
      return D.23468;
      <D.23526>:
      D.23531 = safe_read (&ptr, end, &local_vars_tok, 4);
      if (D.23531 == 0) goto <D.23532>; else goto <D.23533>;
      <D.23532>:
      D.23462 = ctx->report_error;
      if (D.23462 != 0) goto <D.23534>; else goto <D.23535>;
      <D.23534>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23536 = monoeg_strdup ("MethodHeader: Not enough room for local vars tok");
        vinfo->info.message = D.23536;
        vinfo->exception_type = 3;
        D.23466 = ctx->errors;
        D.23537 = monoeg_g_slist_prepend (D.23466, vinfo);
        ctx->errors = D.23537;
      }
      <D.23535>:
      ctx->valid = 0;
      D.23468 = 0;
      return D.23468;
      <D.23533>:
      local_vars_tok.127 = local_vars_tok;
      if (local_vars_tok.127 != 0) goto <D.23539>; else goto <D.23540>;
      <D.23539>:
      local_vars_tok.127 = local_vars_tok;
      D.23541 = local_vars_tok.127 >> 24;
      if (D.23541 != 17) goto <D.23542>; else goto <D.23543>;
      <D.23542>:
      D.23462 = ctx->report_error;
      if (D.23462 != 0) goto <D.23544>; else goto <D.23545>;
      <D.23544>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        local_vars_tok.127 = local_vars_tok;
        D.23541 = local_vars_tok.127 >> 24;
        D.23546 = monoeg_g_strdup_printf ("MethodHeader: Invalid local vars signature table 0x%x", D.23541);
        vinfo->info.message = D.23546;
        vinfo->exception_type = 3;
        D.23466 = ctx->errors;
        D.23547 = monoeg_g_slist_prepend (D.23466, vinfo);
        ctx->errors = D.23547;
      }
      <D.23545>:
      ctx->valid = 0;
      D.23468 = 0;
      return D.23468;
      <D.23543>:
      local_vars_tok.127 = local_vars_tok;
      D.23548 = local_vars_tok.127 & 16777215;
      D.23459 = ctx->image;
      D.23549 = D.23459->tables[17].rows;
      D.23550 = (unsigned int) D.23549;
      if (D.23548 > D.23550) goto <D.23551>; else goto <D.23552>;
      <D.23551>:
      D.23462 = ctx->report_error;
      if (D.23462 != 0) goto <D.23553>; else goto <D.23554>;
      <D.23553>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        local_vars_tok.127 = local_vars_tok;
        D.23548 = local_vars_tok.127 & 16777215;
        D.23555 = monoeg_g_strdup_printf ("MethodHeader: Invalid local vars signature points to invalid row 0x%x", D.23548);
        vinfo->info.message = D.23555;
        vinfo->exception_type = 3;
        D.23466 = ctx->errors;
        D.23556 = monoeg_g_slist_prepend (D.23466, vinfo);
        ctx->errors = D.23556;
      }
      <D.23554>:
      ctx->valid = 0;
      D.23468 = 0;
      return D.23468;
      <D.23552>:
      local_vars_tok.127 = local_vars_tok;
      D.23548 = local_vars_tok.127 & 16777215;
      if (D.23548 == 0) goto <D.23557>; else goto <D.23558>;
      <D.23557>:
      D.23462 = ctx->report_error;
      if (D.23462 != 0) goto <D.23559>; else goto <D.23560>;
      <D.23559>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23561 = monoeg_g_strdup_printf ("MethodHeader: Invalid local vars signature with zero index");
        vinfo->info.message = D.23561;
        vinfo->exception_type = 3;
        D.23466 = ctx->errors;
        D.23562 = monoeg_g_slist_prepend (D.23466, vinfo);
        ctx->errors = D.23562;
      }
      <D.23560>:
      ctx->valid = 0;
      D.23468 = 0;
      return D.23468;
      <D.23558>:
      local_vars_tok.127 = local_vars_tok;
      D.23548 = local_vars_tok.127 & 16777215;
      *locals_token = D.23548;
      <D.23540>:
      fat_header.126 = fat_header;
      D.23563 = fat_header.126 & 4294905828;
      if (D.23563 != 0) goto <D.23564>; else goto <D.23565>;
      <D.23564>:
      D.23462 = ctx->report_error;
      if (D.23462 != 0) goto <D.23566>; else goto <D.23567>;
      <D.23566>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        fat_header.126 = fat_header;
        D.23563 = fat_header.126 & 4294905828;
        D.23568 = monoeg_g_strdup_printf ("MethodHeader: Invalid fat signature flags %x", D.23563);
        vinfo->info.message = D.23568;
        vinfo->exception_type = 3;
        D.23466 = ctx->errors;
        D.23569 = monoeg_g_slist_prepend (D.23466, vinfo);
        ctx->errors = D.23569;
      }
      <D.23567>:
      ctx->valid = 0;
      D.23468 = 0;
      return D.23468;
      <D.23565>:
      ptr.121 = ptr;
      code_size.128 = code_size;
      ptr.129 = ptr.121 + code_size.128;
      if (ptr.129 > end) goto <D.23570>; else goto <D.23574>;
      <D.23574>:
      code_size.128 = code_size;
      D.23575 = ~code_size.128;
      ptr.121 = ptr;
      ptr.122 = (unsigned int) ptr.121;
      if (D.23575 < ptr.122) goto <D.23570>; else goto <D.23571>;
      <D.23570>:
      D.23462 = ctx->report_error;
      if (D.23462 != 0) goto <D.23576>; else goto <D.23577>;
      <D.23576>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        code_size.128 = code_size;
        D.23578 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for code %d", code_size.128);
        vinfo->info.message = D.23578;
        vinfo->exception_type = 3;
        D.23466 = ctx->errors;
        D.23579 = monoeg_g_slist_prepend (D.23466, vinfo);
        ctx->errors = D.23579;
      }
      <D.23577>:
      ctx->valid = 0;
      D.23468 = 0;
      return D.23468;
      <D.23571>:
      fat_header.126 = fat_header;
      D.23580 = fat_header.126 & 8;
      if (D.23580 == 0) goto <D.23581>; else goto <D.23582>;
      <D.23581>:
      D.23468 = 1;
      return D.23468;
      <D.23582>:
      ptr.121 = ptr;
      code_size.128 = code_size;
      ptr.129 = ptr.121 + code_size.128;
      ptr = ptr.129;
      <D.18360>:
      {
        unsigned int section_header;
        unsigned int section_size;
        gboolean is_fat;

        try
          {
            section_header = 0;
            section_size = 0;
            ptr.121 = ptr;
            ptr.130 = dword_align (ptr.121);
            ptr = ptr.130;
            D.23584 = safe_read (&ptr, end, &section_header, 4);
            if (D.23584 == 0) goto <D.23585>; else goto <D.23586>;
            <D.23585>:
            D.23462 = ctx->report_error;
            if (D.23462 != 0) goto <D.23587>; else goto <D.23588>;
            <D.23587>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.23589 = monoeg_strdup ("MethodHeader: Not enough room for data section header");
              vinfo->info.message = D.23589;
              vinfo->exception_type = 3;
              D.23466 = ctx->errors;
              D.23590 = monoeg_g_slist_prepend (D.23466, vinfo);
              ctx->errors = D.23590;
            }
            <D.23588>:
            ctx->valid = 0;
            D.23468 = 0;
            return D.23468;
            <D.23586>:
            section_header.131 = section_header;
            D.23592 = section_header.131 & 62;
            if (D.23592 != 0) goto <D.23593>; else goto <D.23594>;
            <D.23593>:
            D.23462 = ctx->report_error;
            if (D.23462 != 0) goto <D.23595>; else goto <D.23596>;
            <D.23595>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              section_header.131 = section_header;
              D.23592 = section_header.131 & 62;
              D.23597 = monoeg_g_strdup_printf ("MethodHeader: Invalid section header flags 0x%x", D.23592);
              vinfo->info.message = D.23597;
              vinfo->exception_type = 3;
              D.23466 = ctx->errors;
              D.23598 = monoeg_g_slist_prepend (D.23466, vinfo);
              ctx->errors = D.23598;
            }
            <D.23596>:
            ctx->valid = 0;
            D.23468 = 0;
            return D.23468;
            <D.23594>:
            section_header.131 = section_header;
            D.23599 = section_header.131 & 64;
            D.23600 = D.23599 != 0;
            is_fat = (gboolean) D.23600;
            section_header.131 = section_header;
            D.23601 = section_header.131 >> 8;
            if (is_fat != 0) goto <D.23603>; else goto <D.23604>;
            <D.23603>:
            iftmp.132 = 16777215;
            goto <D.23605>;
            <D.23604>:
            iftmp.132 = 255;
            <D.23605>:
            section_size = D.23601 & iftmp.132;
            if (section_size <= 3) goto <D.23606>; else goto <D.23607>;
            <D.23606>:
            D.23462 = ctx->report_error;
            if (D.23462 != 0) goto <D.23608>; else goto <D.23609>;
            <D.23608>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.23610 = monoeg_g_strdup_printf ("MethodHeader: Section size too small");
              vinfo->info.message = D.23610;
              vinfo->exception_type = 3;
              D.23466 = ctx->errors;
              D.23611 = monoeg_g_slist_prepend (D.23466, vinfo);
              ctx->errors = D.23611;
            }
            <D.23609>:
            ctx->valid = 0;
            D.23468 = 0;
            return D.23468;
            <D.23607>:
            ptr.121 = ptr;
            D.23614 = section_size + 4294967292;
            D.23615 = ptr.121 + D.23614;
            if (D.23615 > end) goto <D.23612>; else goto <D.23616>;
            <D.23616>:
            D.23617 = section_size + 4294967292;
            D.23618 = ~D.23617;
            ptr.121 = ptr;
            ptr.122 = (unsigned int) ptr.121;
            if (D.23618 < ptr.122) goto <D.23612>; else goto <D.23613>;
            <D.23612>:
            D.23462 = ctx->report_error;
            if (D.23462 != 0) goto <D.23619>; else goto <D.23620>;
            <D.23619>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.23621 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for section content %d", section_size);
              vinfo->info.message = D.23621;
              vinfo->exception_type = 3;
              D.23466 = ctx->errors;
              D.23622 = monoeg_g_slist_prepend (D.23466, vinfo);
              ctx->errors = D.23622;
            }
            <D.23620>:
            ctx->valid = 0;
            D.23468 = 0;
            return D.23468;
            <D.23613>:
            section_header.131 = section_header;
            D.23623 = section_header.131 & 1;
            if (D.23623 != 0) goto <D.23624>; else goto <D.23625>;
            <D.23624>:
            {
              guint32 i;
              guint32 clauses;

              if (is_fat != 0) goto <D.23627>; else goto <D.23628>;
              <D.23627>:
              iftmp.133 = 24;
              goto <D.23629>;
              <D.23628>:
              iftmp.133 = 12;
              <D.23629>:
              clauses = section_size / iftmp.133;
              if (is_fat != 0) goto <D.23631>; else goto <D.23632>;
              <D.23631>:
              iftmp.134 = 24;
              goto <D.23633>;
              <D.23632>:
              iftmp.134 = 12;
              <D.23633>:
              D.23634 = iftmp.134 * clauses;
              if (D.23634 != section_size) goto <D.23635>; else goto <D.23636>;
              <D.23635>:
              if (is_fat != 0) goto <D.23638>; else goto <D.23639>;
              <D.23638>:
              iftmp.135 = 24;
              goto <D.23640>;
              <D.23639>:
              iftmp.135 = 12;
              <D.23640>:
              D.23641 = iftmp.135 * clauses;
              D.23642 = D.23641 + 4;
              if (D.23642 != section_size) goto <D.23643>; else goto <D.23644>;
              <D.23643>:
              D.23462 = ctx->report_error;
              if (D.23462 != 0) goto <D.23645>; else goto <D.23646>;
              <D.23645>:
              {
                struct MonoVerifyInfoExtended * vinfo;

                vinfo = monoeg_malloc (12);
                vinfo->info.status = 1;
                if (is_fat != 0) goto <D.23648>; else goto <D.23649>;
                <D.23648>:
                iftmp.136 = 24;
                goto <D.23650>;
                <D.23649>:
                iftmp.136 = 12;
                <D.23650>:
                D.23651 = iftmp.136 * clauses;
                D.23652 = monoeg_g_strdup_printf ("MethodHeader: Invalid EH section size %d, it\'s not of the expected size %d", section_size, D.23651);
                vinfo->info.message = D.23652;
                vinfo->exception_type = 3;
                D.23466 = ctx->errors;
                D.23653 = monoeg_g_slist_prepend (D.23466, vinfo);
                ctx->errors = D.23653;
              }
              <D.23646>:
              ctx->valid = 0;
              D.23468 = 0;
              return D.23468;
              <D.23644>:
              <D.23636>:
              i = 0;
              goto <D.18357>;
              <D.18356>:
              {
                unsigned int flags;
                unsigned int class_token;

                try
                  {
                    ptr.121 = ptr;
                    D.23654 = MEM[(unsigned char *)ptr.121];
                    flags = (unsigned int) D.23654;
                    class_token = 0;
                    ptr.121 = ptr;
                    if (is_fat != 0) goto <D.23656>; else goto <D.23657>;
                    <D.23656>:
                    iftmp.137 = 20;
                    goto <D.23658>;
                    <D.23657>:
                    iftmp.137 = 8;
                    <D.23658>:
                    ptr.138 = ptr.121 + iftmp.137;
                    ptr = ptr.138;
                    D.23660 = safe_read (&ptr, end, &class_token, 4);
                    if (D.23660 == 0) goto <D.23661>; else goto <D.23662>;
                    <D.23661>:
                    D.23462 = ctx->report_error;
                    if (D.23462 != 0) goto <D.23663>; else goto <D.23664>;
                    <D.23663>:
                    {
                      struct MonoVerifyInfoExtended * vinfo;

                      vinfo = monoeg_malloc (12);
                      vinfo->info.status = 1;
                      D.23665 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for section %d", i);
                      vinfo->info.message = D.23665;
                      vinfo->exception_type = 3;
                      D.23466 = ctx->errors;
                      D.23666 = monoeg_g_slist_prepend (D.23466, vinfo);
                      ctx->errors = D.23666;
                    }
                    <D.23664>:
                    ctx->valid = 0;
                    D.23468 = 0;
                    return D.23468;
                    <D.23662>:
                    if (flags == 0) goto <D.23667>; else goto <D.23668>;
                    <D.23667>:
                    class_token.139 = class_token;
                    if (class_token.139 != 0) goto <D.23670>; else goto <D.23671>;
                    <D.23670>:
                    {
                      guint table;

                      class_token.139 = class_token;
                      table = class_token.139 >> 24;
                      D.23672 = table + 4294967295;
                      D.23673 = D.23672 > 1;
                      D.23674 = table != 27;
                      D.23675 = D.23673 & D.23674;
                      if (D.23675 != 0) goto <D.23676>; else goto <D.23677>;
                      <D.23676>:
                      D.23462 = ctx->report_error;
                      if (D.23462 != 0) goto <D.23678>; else goto <D.23679>;
                      <D.23678>:
                      {
                        struct MonoVerifyInfoExtended * vinfo;

                        vinfo = monoeg_malloc (12);
                        vinfo->info.status = 1;
                        D.23680 = monoeg_g_strdup_printf ("MethodHeader: Invalid section %d class token table %x", i, table);
                        vinfo->info.message = D.23680;
                        vinfo->exception_type = 3;
                        D.23466 = ctx->errors;
                        D.23681 = monoeg_g_slist_prepend (D.23466, vinfo);
                        ctx->errors = D.23681;
                      }
                      <D.23679>:
                      ctx->valid = 0;
                      D.23468 = 0;
                      return D.23468;
                      <D.23677>:
                      class_token.139 = class_token;
                      D.23682 = class_token.139 & 16777215;
                      D.23459 = ctx->image;
                      D.23683 = D.23459->tables[table].rows;
                      D.23684 = (unsigned int) D.23683;
                      if (D.23682 > D.23684) goto <D.23685>; else goto <D.23686>;
                      <D.23685>:
                      D.23462 = ctx->report_error;
                      if (D.23462 != 0) goto <D.23687>; else goto <D.23688>;
                      <D.23687>:
                      {
                        struct MonoVerifyInfoExtended * vinfo;

                        vinfo = monoeg_malloc (12);
                        vinfo->info.status = 1;
                        class_token.139 = class_token;
                        D.23682 = class_token.139 & 16777215;
                        D.23689 = monoeg_g_strdup_printf ("MethodHeader: Invalid section %d class token index %x", i, D.23682);
                        vinfo->info.message = D.23689;
                        vinfo->exception_type = 3;
                        D.23466 = ctx->errors;
                        D.23690 = monoeg_g_slist_prepend (D.23466, vinfo);
                        ctx->errors = D.23690;
                      }
                      <D.23688>:
                      ctx->valid = 0;
                      D.23468 = 0;
                      return D.23468;
                      <D.23686>:
                    }
                    <D.23671>:
                    <D.23668>:
                  }
                finally
                  {
                    class_token = {CLOBBER};
                  }
              }
              i = i + 1;
              <D.18357>:
              if (i < clauses) goto <D.18356>; else goto <D.18358>;
              <D.18358>:
            }
            <D.23625>:
            section_header.131 = section_header;
            D.23691 = section_header.131 & 128;
            if (D.23691 == 0) goto <D.18359>; else goto <D.23692>;
            <D.23692>:
          }
        finally
          {
            section_header = {CLOBBER};
          }
      }
      goto <D.18360>;
      <D.18359>:
      D.23468 = 1;
      return D.23468;
    }
  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.23700;
  const char * D.23701;
  unsigned int D.23702;
  unsigned int D.23703;

  D.23701 = ptr + 3;
  D.23702 = (unsigned int) D.23701;
  D.23703 = D.23702 & 4294967292;
  D.23700 = (const char *) D.23703;
  return D.23700;
}


verify_memberref_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.23705;
  unsigned int D.23706;
  int D.23707;
  int D.23710;
  gchar * D.23713;
  struct GSList * D.23714;
  struct GSList * D.23715;
  <unnamed-unsigned:24> D.23716;
  int D.23717;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.23705 = ctx->image;
      table = &D.23705->tables[10];
      i = 0;
      goto <D.18606>;
      <D.18605>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.23706 = data[2];
      D.23707 = is_valid_method_or_field_signature (ctx, D.23706);
      if (D.23707 == 0) goto <D.23708>; else goto <D.23709>;
      <D.23708>:
      D.23710 = ctx->report_error;
      if (D.23710 != 0) goto <D.23711>; else goto <D.23712>;
      <D.23711>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23706 = data[2];
        D.23713 = monoeg_g_strdup_printf ("Invalid MemberRef row %d Signature field  0x%08x", i, D.23706);
        vinfo->info.message = D.23713;
        vinfo->exception_type = 3;
        D.23714 = ctx->errors;
        D.23715 = monoeg_g_slist_prepend (D.23714, vinfo);
        ctx->errors = D.23715;
      }
      <D.23712>:
      ctx->valid = 0;
      return;
      <D.23709>:
      i = i + 1;
      <D.18606>:
      D.23716 = table->rows;
      D.23717 = (int) D.23716;
      if (D.23717 > i) goto <D.18605>; else goto <D.18607>;
      <D.18607>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_method_or_field_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.23721;
  int D.23724;
  gchar * D.23727;
  struct GSList * D.23728;
  struct GSList * D.23729;
  gboolean D.23730;
  const char * ptr.140;
  unsigned int size.141;
  int D.23733;
  gchar * D.23738;
  struct GSList * D.23739;
  const char * ptr.142;
  unsigned int signature.143;
  guint32 size;
  unsigned int signature;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      signature = 0;
      ptr = 0B;
      D.23721 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.23721 == 0) goto <D.23722>; else goto <D.23723>;
      <D.23722>:
      D.23724 = ctx->report_error;
      if (D.23724 != 0) goto <D.23725>; else goto <D.23726>;
      <D.23725>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23727 = monoeg_strdup ("MemberRefSig: Could not decode signature header");
        vinfo->info.message = D.23727;
        vinfo->exception_type = 3;
        D.23728 = ctx->errors;
        D.23729 = monoeg_g_slist_prepend (D.23728, vinfo);
        ctx->errors = D.23729;
      }
      <D.23726>:
      ctx->valid = 0;
      D.23730 = 0;
      return D.23730;
      <D.23723>:
      ptr.140 = ptr;
      size.141 = size;
      end = ptr.140 + size.141;
      D.23733 = safe_read (&ptr, end, &signature, 1);
      if (D.23733 == 0) goto <D.23734>; else goto <D.23735>;
      <D.23734>:
      D.23724 = ctx->report_error;
      if (D.23724 != 0) goto <D.23736>; else goto <D.23737>;
      <D.23736>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23738 = monoeg_strdup ("MemberRefSig: Not enough room for the call conv");
        vinfo->info.message = D.23738;
        vinfo->exception_type = 3;
        D.23728 = ctx->errors;
        D.23739 = monoeg_g_slist_prepend (D.23728, vinfo);
        ctx->errors = D.23739;
      }
      <D.23737>:
      ctx->valid = 0;
      D.23730 = 0;
      return D.23730;
      <D.23735>:
      ptr.140 = ptr;
      ptr.142 = ptr.140 + 4294967295;
      ptr = ptr.142;
      signature.143 = signature;
      if (signature.143 == 6) goto <D.23742>; else goto <D.23743>;
      <D.23742>:
      D.23730 = parse_field (ctx, &ptr, end);
      return D.23730;
      <D.23743>:
      D.23730 = parse_method_signature (ctx, &ptr, end, 1, 0);
      return D.23730;
    }
  finally
    {
      size = {CLOBBER};
      signature = {CLOBBER};
      ptr = {CLOBBER};
    }
}


verify_cattr_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.23746;
  unsigned int D.23747;
  int D.23748;
  int D.23751;
  gchar * D.23754;
  struct GSList * D.23755;
  struct GSList * D.23756;
  unsigned int D.23757;
  unsigned int D.23758;
  gchar * D.23761;
  struct GSList * D.23762;
  int D.23763;
  _Bool D.23764;
  long int D.23765;
  long int D.23766;
  unsigned int size.144;
  const char * ptr.145;
  int D.23771;
  gchar * D.23776;
  struct GSList * D.23777;
  <unnamed-unsigned:24> D.23778;
  int D.23779;
  struct MonoTableInfo * table;
  struct MonoMethod * ctor;
  const char * ptr;
  guint32 data[3];
  guint32 mtoken;
  guint32 size;
  int i;

  try
    {
      D.23746 = ctx->image;
      table = &D.23746->tables[12];
      i = 0;
      goto <D.18652>;
      <D.18651>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.23747 = data[2];
      D.23748 = is_valid_cattr_blob (ctx, D.23747);
      if (D.23748 == 0) goto <D.23749>; else goto <D.23750>;
      <D.23749>:
      D.23751 = ctx->report_error;
      if (D.23751 != 0) goto <D.23752>; else goto <D.23753>;
      <D.23752>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23747 = data[2];
        D.23754 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d Value field 0x%08x", i, D.23747);
        vinfo->info.message = D.23754;
        vinfo->exception_type = 3;
        D.23755 = ctx->errors;
        D.23756 = monoeg_g_slist_prepend (D.23755, vinfo);
        ctx->errors = D.23756;
      }
      <D.23753>:
      ctx->valid = 0;
      return;
      <D.23750>:
      D.23757 = data[1];
      mtoken = D.23757 >> 3;
      D.23757 = data[1];
      D.23758 = D.23757 & 7;
      switch (D.23758) <default: <D.18648>, case 2: <D.18645>, case 3: <D.18647>>
      <D.18645>:
      mtoken = mtoken | 100663296;
      goto <D.18646>;
      <D.18647>:
      mtoken = mtoken | 167772160;
      goto <D.18646>;
      <D.18648>:
      D.23751 = ctx->report_error;
      if (D.23751 != 0) goto <D.23759>; else goto <D.23760>;
      <D.23759>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23757 = data[1];
        D.23761 = monoeg_g_strdup_printf ("Invalid CustomAttribute constructor row %d Token 0x%08x", i, D.23757);
        vinfo->info.message = D.23761;
        vinfo->exception_type = 3;
        D.23755 = ctx->errors;
        D.23762 = monoeg_g_slist_prepend (D.23755, vinfo);
        ctx->errors = D.23762;
      }
      <D.23760>:
      ctx->valid = 0;
      return;
      <D.18646>:
      D.23746 = ctx->image;
      ctor = mono_get_method (D.23746, mtoken, 0B);
      D.23747 = data[2];
      D.23763 = decode_signature_header (ctx, D.23747, &size, &ptr);
      D.23764 = D.23763 == 0;
      D.23765 = (long int) D.23764;
      D.23766 = __builtin_expect (D.23765, 0);
      if (D.23766 != 0) goto <D.23767>; else goto <D.23768>;
      <D.23767>:
      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.23768>:
      size.144 = size;
      ptr.145 = ptr;
      D.23771 = is_valid_cattr_content (ctx, ctor, ptr.145, size.144);
      if (D.23771 == 0) goto <D.23772>; else goto <D.23773>;
      <D.23772>:
      D.23751 = ctx->report_error;
      if (D.23751 != 0) goto <D.23774>; else goto <D.23775>;
      <D.23774>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23747 = data[2];
        D.23776 = monoeg_g_strdup_printf ("Invalid CustomAttribute content row %d Value field 0x%08x", i, D.23747);
        vinfo->info.message = D.23776;
        vinfo->exception_type = 3;
        D.23755 = ctx->errors;
        D.23777 = monoeg_g_slist_prepend (D.23755, vinfo);
        ctx->errors = D.23777;
      }
      <D.23775>:
      ctx->valid = 0;
      return;
      <D.23773>:
      i = i + 1;
      <D.18652>:
      D.23778 = table->rows;
      D.23779 = (int) D.23778;
      if (D.23779 > i) goto <D.18651>; else goto <D.18653>;
      <D.18653>:
    }
  finally
    {
      ptr = {CLOBBER};
      data = {CLOBBER};
      size = {CLOBBER};
    }
}


is_valid_cattr_blob (struct VerifyContext * ctx, guint32 offset)
{
  gboolean D.23785;
  int D.23786;
  int D.23789;
  gchar * D.23792;
  struct GSList * D.23793;
  struct GSList * D.23794;
  const char * ptr.146;
  unsigned int size.147;
  int D.23797;
  gchar * D.23802;
  struct GSList * D.23803;
  unsigned int prolog.148;
  gchar * D.23809;
  struct GSList * D.23810;
  guint32 size;
  unsigned int prolog;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      prolog = 0;
      ptr = 0B;
      if (offset == 0) goto <D.23783>; else goto <D.23784>;
      <D.23783>:
      D.23785 = 1;
      return D.23785;
      <D.23784>:
      D.23786 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.23786 == 0) goto <D.23787>; else goto <D.23788>;
      <D.23787>:
      D.23789 = ctx->report_error;
      if (D.23789 != 0) goto <D.23790>; else goto <D.23791>;
      <D.23790>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23792 = monoeg_strdup ("CustomAttribute: Could not decode signature header");
        vinfo->info.message = D.23792;
        vinfo->exception_type = 3;
        D.23793 = ctx->errors;
        D.23794 = monoeg_g_slist_prepend (D.23793, vinfo);
        ctx->errors = D.23794;
      }
      <D.23791>:
      ctx->valid = 0;
      D.23785 = 0;
      return D.23785;
      <D.23788>:
      ptr.146 = ptr;
      size.147 = size;
      end = ptr.146 + size.147;
      D.23797 = safe_read (&ptr, end, &prolog, 2);
      if (D.23797 == 0) goto <D.23798>; else goto <D.23799>;
      <D.23798>:
      D.23789 = ctx->report_error;
      if (D.23789 != 0) goto <D.23800>; else goto <D.23801>;
      <D.23800>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23802 = monoeg_strdup ("CustomAttribute: Not enough room for prolog");
        vinfo->info.message = D.23802;
        vinfo->exception_type = 3;
        D.23793 = ctx->errors;
        D.23803 = monoeg_g_slist_prepend (D.23793, vinfo);
        ctx->errors = D.23803;
      }
      <D.23801>:
      ctx->valid = 0;
      D.23785 = 0;
      return D.23785;
      <D.23799>:
      prolog.148 = prolog;
      if (prolog.148 != 1) goto <D.23805>; else goto <D.23806>;
      <D.23805>:
      D.23789 = ctx->report_error;
      if (D.23789 != 0) goto <D.23807>; else goto <D.23808>;
      <D.23807>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        prolog.148 = prolog;
        D.23809 = monoeg_g_strdup_printf ("CustomAttribute: Prolog is 0x%x, expected 0x1", prolog.148);
        vinfo->info.message = D.23809;
        vinfo->exception_type = 3;
        D.23793 = ctx->errors;
        D.23810 = monoeg_g_slist_prepend (D.23793, vinfo);
        ctx->errors = D.23810;
      }
      <D.23808>:
      ctx->valid = 0;
      D.23785 = 0;
      return D.23785;
      <D.23806>:
      D.23785 = 1;
      return D.23785;
    }
  finally
    {
      size = {CLOBBER};
      prolog = {CLOBBER};
      ptr = {CLOBBER};
    }
}


is_valid_cattr_content (struct VerifyContext * ctx, struct MonoMethod * ctor, const char * ptr, guint32 size)
{
  int D.23815;
  gchar * D.23818;
  struct GSList * D.23819;
  struct GSList * D.23820;
  gboolean D.23821;
  int D.23822;
  const char * D.23827;
  gchar * D.23828;
  struct GSList * D.23829;
  short int D.23832;
  unsigned char D.23834;
  unsigned char D.23835;
  gchar * D.23838;
  struct GSList * D.23839;
  const char * ptr.149;
  int D.23841;
  gchar * D.23846;
  struct GSList * D.23847;
  unsigned int prolog.150;
  gchar * D.23853;
  struct GSList * D.23854;
  short unsigned int D.23855;
  int D.23856;
  int D.23859;
  gchar * D.23864;
  struct GSList * D.23865;
  int D.23866;
  gchar * D.23871;
  struct GSList * D.23872;
  unsigned int kind.151;
  unsigned int D.23874;
  gchar * D.23879;
  struct GSList * D.23880;
  int D.23881;
  gchar * D.23886;
  struct GSList * D.23887;
  unsigned int D.23888;
  unsigned char D.23891;
  struct MonoClass * D.23900;
  struct MonoClass * D.23904;
  int D.23908;
  gchar * D.23913;
  struct GSList * D.23914;
  unsigned int etype.152;
  unsigned int etype.153;
  _Bool D.23922;
  _Bool D.23923;
  _Bool D.23924;
  unsigned int etype.154;
  unsigned int D.23929;
  _Bool D.23930;
  _Bool D.23931;
  _Bool D.23932;
  unsigned char iftmp.155;
  gchar * D.23942;
  struct GSList * D.23943;
  struct MonoClass * D.23944;
  gchar * D.23948;
  struct GSList * D.23949;
  int D.23950;
  int D.23953;
  unsigned int i.156;
  unsigned int num_named.157;
  struct MonoError error;
  unsigned int prolog;
  const char * end;
  struct MonoMethodSignature * sig;
  int args;
  int i;
  unsigned int num_named;

  try
    {
      prolog = 0;
      if (ctor == 0B) goto <D.23813>; else goto <D.23814>;
      <D.23813>:
      D.23815 = ctx->report_error;
      if (D.23815 != 0) goto <D.23816>; else goto <D.23817>;
      <D.23816>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23818 = monoeg_strdup ("CustomAttribute: Invalid constructor");
        vinfo->info.message = D.23818;
        vinfo->exception_type = 3;
        D.23819 = ctx->errors;
        D.23820 = monoeg_g_slist_prepend (D.23819, vinfo);
        ctx->errors = D.23820;
      }
      <D.23817>:
      ctx->valid = 0;
      D.23821 = 0;
      return D.23821;
      <D.23814>:
      sig = mono_method_signature_checked (ctor, &error);
      D.23822 = mono_error_ok (&error);
      if (D.23822 == 0) goto <D.23823>; else goto <D.23824>;
      <D.23823>:
      D.23815 = ctx->report_error;
      if (D.23815 != 0) goto <D.23825>; else goto <D.23826>;
      <D.23825>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23827 = mono_error_get_message (&error);
        D.23828 = monoeg_g_strdup_printf ("CustomAttribute: Invalid constructor signature %s", D.23827);
        vinfo->info.message = D.23828;
        vinfo->exception_type = 3;
        D.23819 = ctx->errors;
        D.23829 = monoeg_g_slist_prepend (D.23819, vinfo);
        ctx->errors = D.23829;
      }
      <D.23826>:
      ctx->valid = 0;
      mono_error_cleanup (&error);
      D.23821 = 0;
      return D.23821;
      <D.23824>:
      D.23832 = sig->sentinelpos;
      if (D.23832 != -1) goto <D.23830>; else goto <D.23833>;
      <D.23833>:
      D.23834 = BIT_FIELD_REF <*sig, 8, 80>;
      D.23835 = D.23834 & 63;
      if (D.23835 == 5) goto <D.23830>; else goto <D.23831>;
      <D.23830>:
      D.23815 = ctx->report_error;
      if (D.23815 != 0) goto <D.23836>; else goto <D.23837>;
      <D.23836>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23838 = monoeg_strdup ("CustomAttribute: Constructor cannot have VARAG signature");
        vinfo->info.message = D.23838;
        vinfo->exception_type = 3;
        D.23819 = ctx->errors;
        D.23839 = monoeg_g_slist_prepend (D.23819, vinfo);
        ctx->errors = D.23839;
      }
      <D.23837>:
      ctx->valid = 0;
      D.23821 = 0;
      return D.23821;
      <D.23831>:
      ptr.149 = ptr;
      end = ptr.149 + size;
      D.23841 = safe_read (&ptr, end, &prolog, 2);
      if (D.23841 == 0) goto <D.23842>; else goto <D.23843>;
      <D.23842>:
      D.23815 = ctx->report_error;
      if (D.23815 != 0) goto <D.23844>; else goto <D.23845>;
      <D.23844>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23846 = monoeg_strdup ("CustomAttribute: Not enough room for prolog");
        vinfo->info.message = D.23846;
        vinfo->exception_type = 3;
        D.23819 = ctx->errors;
        D.23847 = monoeg_g_slist_prepend (D.23819, vinfo);
        ctx->errors = D.23847;
      }
      <D.23845>:
      ctx->valid = 0;
      D.23821 = 0;
      return D.23821;
      <D.23843>:
      prolog.150 = prolog;
      if (prolog.150 != 1) goto <D.23849>; else goto <D.23850>;
      <D.23849>:
      D.23815 = ctx->report_error;
      if (D.23815 != 0) goto <D.23851>; else goto <D.23852>;
      <D.23851>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        prolog.150 = prolog;
        D.23853 = monoeg_g_strdup_printf ("CustomAttribute: Prolog is 0x%x, expected 0x1", prolog.150);
        vinfo->info.message = D.23853;
        vinfo->exception_type = 3;
        D.23819 = ctx->errors;
        D.23854 = monoeg_g_slist_prepend (D.23819, vinfo);
        ctx->errors = D.23854;
      }
      <D.23852>:
      ctx->valid = 0;
      D.23821 = 0;
      return D.23821;
      <D.23850>:
      D.23855 = sig->param_count;
      args = (int) D.23855;
      i = 0;
      goto <D.18194>;
      <D.18193>:
      {
        struct MonoType * arg_type;

        arg_type = sig->params[i];
        D.23856 = is_valid_fixed_param (ctx, arg_type, &ptr, end);
        if (D.23856 == 0) goto <D.23857>; else goto <D.23858>;
        <D.23857>:
        D.23821 = 0;
        return D.23821;
        <D.23858>:
      }
      i = i + 1;
      <D.18194>:
      if (i < args) goto <D.18193>; else goto <D.18195>;
      <D.18195>:
      D.23859 = safe_read (&ptr, end, &num_named, 2);
      if (D.23859 == 0) goto <D.23860>; else goto <D.23861>;
      <D.23860>:
      D.23815 = ctx->report_error;
      if (D.23815 != 0) goto <D.23862>; else goto <D.23863>;
      <D.23862>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23864 = monoeg_strdup ("CustomAttribute: Not enough space for num_named field");
        vinfo->info.message = D.23864;
        vinfo->exception_type = 3;
        D.23819 = ctx->errors;
        D.23865 = monoeg_g_slist_prepend (D.23819, vinfo);
        ctx->errors = D.23865;
      }
      <D.23863>:
      ctx->valid = 0;
      D.23821 = 0;
      return D.23821;
      <D.23861>:
      i = 0;
      goto <D.18210>;
      <D.18209>:
      {
        struct MonoType * type;
        struct MonoType simple_type;
        unsigned int kind;

        try
          {
            simple_type = {};
            D.23866 = safe_read (&ptr, end, &kind, 1);
            if (D.23866 == 0) goto <D.23867>; else goto <D.23868>;
            <D.23867>:
            D.23815 = ctx->report_error;
            if (D.23815 != 0) goto <D.23869>; else goto <D.23870>;
            <D.23869>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.23871 = monoeg_g_strdup_printf ("CustomAttribute: Not enough space for named parameter %d kind", i);
              vinfo->info.message = D.23871;
              vinfo->exception_type = 3;
              D.23819 = ctx->errors;
              D.23872 = monoeg_g_slist_prepend (D.23819, vinfo);
              ctx->errors = D.23872;
            }
            <D.23870>:
            ctx->valid = 0;
            D.23821 = 0;
            return D.23821;
            <D.23868>:
            kind.151 = kind;
            D.23874 = kind.151 + 4294967213;
            if (D.23874 > 1) goto <D.23875>; else goto <D.23876>;
            <D.23875>:
            D.23815 = ctx->report_error;
            if (D.23815 != 0) goto <D.23877>; else goto <D.23878>;
            <D.23877>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              kind.151 = kind;
              D.23879 = monoeg_g_strdup_printf ("CustomAttribute: Invalid named parameter %d kind %x", i, kind.151);
              vinfo->info.message = D.23879;
              vinfo->exception_type = 3;
              D.23819 = ctx->errors;
              D.23880 = monoeg_g_slist_prepend (D.23819, vinfo);
              ctx->errors = D.23880;
            }
            <D.23878>:
            ctx->valid = 0;
            D.23821 = 0;
            return D.23821;
            <D.23876>:
            D.23881 = safe_read (&ptr, end, &kind, 1);
            if (D.23881 == 0) goto <D.23882>; else goto <D.23883>;
            <D.23882>:
            D.23815 = ctx->report_error;
            if (D.23815 != 0) goto <D.23884>; else goto <D.23885>;
            <D.23884>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.23886 = monoeg_g_strdup_printf ("CustomAttribute: Not enough space for named parameter %d type", i);
              vinfo->info.message = D.23886;
              vinfo->exception_type = 3;
              D.23819 = ctx->errors;
              D.23887 = monoeg_g_slist_prepend (D.23819, vinfo);
              ctx->errors = D.23887;
            }
            <D.23885>:
            ctx->valid = 0;
            D.23821 = 0;
            return D.23821;
            <D.23883>:
            kind.151 = kind;
            D.23888 = kind.151 + 4294967294;
            if (D.23888 <= 12) goto <D.23889>; else goto <D.23890>;
            <D.23889>:
            kind.151 = kind;
            D.23891 = (unsigned char) kind.151;
            simple_type.type = D.23891;
            type = &simple_type;
            goto <D.23892>;
            <D.23890>:
            kind.151 = kind;
            if (kind.151 == 85) goto <D.23893>; else goto <D.23894>;
            <D.23893>:
            {
              struct MonoClass * klass;

              klass = get_enum_by_encoded_name (ctx, &ptr, end);
              if (klass == 0B) goto <D.23895>; else goto <D.23896>;
              <D.23895>:
              D.23821 = 0;
              return D.23821;
              <D.23896>:
              type = &klass->byval_arg;
            }
            goto <D.23897>;
            <D.23894>:
            kind.151 = kind;
            if (kind.151 == 80) goto <D.23898>; else goto <D.23899>;
            <D.23898>:
            D.23900 = mono_defaults.systemtype_class;
            type = &D.23900->byval_arg;
            goto <D.23901>;
            <D.23899>:
            kind.151 = kind;
            if (kind.151 == 81) goto <D.23902>; else goto <D.23903>;
            <D.23902>:
            D.23904 = mono_defaults.object_class;
            type = &D.23904->byval_arg;
            goto <D.23905>;
            <D.23903>:
            kind.151 = kind;
            if (kind.151 == 29) goto <D.23906>; else goto <D.23907>;
            <D.23906>:
            {
              struct MonoClass * klass;
              unsigned int etype;

              try
                {
                  etype = 0;
                  D.23908 = safe_read (&ptr, end, &etype, 1);
                  if (D.23908 == 0) goto <D.23909>; else goto <D.23910>;
                  <D.23909>:
                  D.23815 = ctx->report_error;
                  if (D.23815 != 0) goto <D.23911>; else goto <D.23912>;
                  <D.23911>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (12);
                    vinfo->info.status = 1;
                    D.23913 = monoeg_strdup ("CustomAttribute: Not enough room for array element type");
                    vinfo->info.message = D.23913;
                    vinfo->exception_type = 3;
                    D.23819 = ctx->errors;
                    D.23914 = monoeg_g_slist_prepend (D.23819, vinfo);
                    ctx->errors = D.23914;
                  }
                  <D.23912>:
                  ctx->valid = 0;
                  D.23821 = 0;
                  return D.23821;
                  <D.23910>:
                  etype.152 = etype;
                  if (etype.152 == 85) goto <D.23916>; else goto <D.23917>;
                  <D.23916>:
                  klass = get_enum_by_encoded_name (ctx, &ptr, end);
                  if (klass == 0B) goto <D.23918>; else goto <D.23919>;
                  <D.23918>:
                  D.23821 = 0;
                  return D.23821;
                  <D.23919>:
                  goto <D.23920>;
                  <D.23917>:
                  etype.153 = etype;
                  D.23922 = etype.153 == 80;
                  D.23923 = etype.153 == 18;
                  D.23924 = D.23922 | D.23923;
                  if (D.23924 != 0) goto <D.23925>; else goto <D.23926>;
                  <D.23925>:
                  klass = mono_defaults.systemtype_class;
                  goto <D.23927>;
                  <D.23926>:
                  etype.154 = etype;
                  D.23929 = etype.154 + 4294967294;
                  D.23930 = D.23929 <= 12;
                  D.23931 = etype.154 == 81;
                  D.23932 = D.23930 | D.23931;
                  if (D.23932 != 0) goto <D.23933>; else goto <D.23934>;
                  <D.23933>:
                  etype.152 = etype;
                  if (etype.152 != 81) goto <D.23936>; else goto <D.23937>;
                  <D.23936>:
                  etype.152 = etype;
                  iftmp.155 = (unsigned char) etype.152;
                  goto <D.23938>;
                  <D.23937>:
                  iftmp.155 = 28;
                  <D.23938>:
                  simple_type.type = iftmp.155;
                  klass = mono_class_from_mono_type (&simple_type);
                  goto <D.23939>;
                  <D.23934>:
                  D.23815 = ctx->report_error;
                  if (D.23815 != 0) goto <D.23940>; else goto <D.23941>;
                  <D.23940>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (12);
                    vinfo->info.status = 1;
                    etype.152 = etype;
                    D.23942 = monoeg_g_strdup_printf ("CustomAttribute: Invalid array element type %x", etype.152);
                    vinfo->info.message = D.23942;
                    vinfo->exception_type = 3;
                    D.23819 = ctx->errors;
                    D.23943 = monoeg_g_slist_prepend (D.23819, vinfo);
                    ctx->errors = D.23943;
                  }
                  <D.23941>:
                  ctx->valid = 0;
                  D.23821 = 0;
                  return D.23821;
                  <D.23939>:
                  <D.23927>:
                  <D.23920>:
                  D.23944 = mono_array_class_get (klass, 1);
                  type = &D.23944->byval_arg;
                }
              finally
                {
                  etype = {CLOBBER};
                }
            }
            goto <D.23945>;
            <D.23907>:
            D.23815 = ctx->report_error;
            if (D.23815 != 0) goto <D.23946>; else goto <D.23947>;
            <D.23946>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              kind.151 = kind;
              D.23948 = monoeg_g_strdup_printf ("CustomAttribute: Invalid named parameter type %x", kind.151);
              vinfo->info.message = D.23948;
              vinfo->exception_type = 3;
              D.23819 = ctx->errors;
              D.23949 = monoeg_g_slist_prepend (D.23819, vinfo);
              ctx->errors = D.23949;
            }
            <D.23947>:
            ctx->valid = 0;
            D.23821 = 0;
            return D.23821;
            <D.23945>:
            <D.23905>:
            <D.23901>:
            <D.23897>:
            <D.23892>:
            D.23950 = is_valid_ser_string (ctx, &ptr, end);
            if (D.23950 == 0) goto <D.23951>; else goto <D.23952>;
            <D.23951>:
            D.23821 = 0;
            return D.23821;
            <D.23952>:
            D.23953 = is_valid_fixed_param (ctx, type, &ptr, end);
            if (D.23953 == 0) goto <D.23954>; else goto <D.23955>;
            <D.23954>:
            D.23821 = 0;
            return D.23821;
            <D.23955>:
          }
        finally
          {
            simple_type = {CLOBBER};
            kind = {CLOBBER};
          }
      }
      i = i + 1;
      <D.18210>:
      i.156 = (unsigned int) i;
      num_named.157 = num_named;
      if (i.156 < num_named.157) goto <D.18209>; else goto <D.18211>;
      <D.18211>:
      D.23821 = 1;
      return D.23821;
    }
  finally
    {
      error = {CLOBBER};
      prolog = {CLOBBER};
      num_named = {CLOBBER};
    }
}


get_enum_by_encoded_name (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.158;
  int D.23965;
  struct MonoClass * D.23968;
  const char * str_start.159;
  unsigned int str_len.160;
  int D.23974;
  gchar * D.23977;
  struct GSList * D.23978;
  struct GSList * D.23979;
  unsigned int D.23980;
  char * D.23981;
  struct MonoImage * D.23982;
  gchar * D.23987;
  struct GSList * D.23988;
  unsigned char D.23992;
  unsigned char D.23993;
  const char * D.23996;
  const char * D.23997;
  gchar * D.23998;
  struct GSList * D.23999;
  const char * ptr.161;
  struct MonoType * type;
  struct MonoClass * klass;
  const char * str_start;
  const char * ptr;
  char * enum_name;
  guint32 str_len;

  try
    {
      str_start = 0B;
      ptr.158 = *_ptr;
      ptr = ptr.158;
      str_len = 0;
      D.23965 = is_valid_ser_string_full (ctx, &str_start, &str_len, &ptr, end);
      if (D.23965 == 0) goto <D.23966>; else goto <D.23967>;
      <D.23966>:
      D.23968 = 0B;
      return D.23968;
      <D.23967>:
      str_start.159 = str_start;
      if (str_start.159 == 0B) goto <D.23969>; else goto <D.23972>;
      <D.23972>:
      str_len.160 = str_len;
      if (str_len.160 == 0) goto <D.23969>; else goto <D.23970>;
      <D.23969>:
      D.23974 = ctx->report_error;
      if (D.23974 != 0) goto <D.23975>; else goto <D.23976>;
      <D.23975>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23977 = monoeg_strdup ("CustomAttribute: Null or empty enum name");
        vinfo->info.message = D.23977;
        vinfo->exception_type = 3;
        D.23978 = ctx->errors;
        D.23979 = monoeg_g_slist_prepend (D.23978, vinfo);
        ctx->errors = D.23979;
      }
      <D.23976>:
      ctx->valid = 0;
      D.23968 = 0B;
      return D.23968;
      <D.23970>:
      str_len.160 = str_len;
      D.23980 = str_len.160 + 1;
      str_start.159 = str_start;
      enum_name = monoeg_g_memdup (str_start.159, D.23980);
      str_len.160 = str_len;
      D.23981 = enum_name + str_len.160;
      *D.23981 = 0;
      D.23982 = ctx->image;
      type = mono_reflection_type_from_name (enum_name, D.23982);
      if (type == 0B) goto <D.23983>; else goto <D.23984>;
      <D.23983>:
      D.23974 = ctx->report_error;
      if (D.23974 != 0) goto <D.23985>; else goto <D.23986>;
      <D.23985>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23987 = monoeg_g_strdup_printf ("CustomAttribute: Invalid enum class %s", enum_name);
        vinfo->info.message = D.23987;
        vinfo->exception_type = 3;
        D.23978 = ctx->errors;
        D.23988 = monoeg_g_slist_prepend (D.23978, vinfo);
        ctx->errors = D.23988;
      }
      <D.23986>:
      ctx->valid = 0;
      monoeg_g_free (enum_name);
      D.23968 = 0B;
      return D.23968;
      <D.23984>:
      monoeg_g_free (enum_name);
      klass = mono_class_from_mono_type (type);
      if (klass == 0B) goto <D.23989>; else goto <D.23991>;
      <D.23991>:
      D.23992 = BIT_FIELD_REF <*klass, 8, 160>;
      D.23993 = D.23992 & 16;
      if (D.23993 == 0) goto <D.23989>; else goto <D.23990>;
      <D.23989>:
      D.23974 = ctx->report_error;
      if (D.23974 != 0) goto <D.23994>; else goto <D.23995>;
      <D.23994>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23996 = klass->name;
        D.23997 = klass->name_space;
        D.23998 = monoeg_g_strdup_printf ("CustomAttribute:Class %s::%s is not an enum", D.23997, D.23996);
        vinfo->info.message = D.23998;
        vinfo->exception_type = 3;
        D.23978 = ctx->errors;
        D.23999 = monoeg_g_slist_prepend (D.23978, vinfo);
        ctx->errors = D.23999;
      }
      <D.23995>:
      ctx->valid = 0;
      D.23968 = 0B;
      return D.23968;
      <D.23990>:
      ptr.161 = ptr;
      *_ptr = ptr.161;
      D.23968 = klass;
      return D.23968;
    }
  finally
    {
      str_start = {CLOBBER};
      ptr = {CLOBBER};
      str_len = {CLOBBER};
    }
}


is_valid_ser_string_full (struct VerifyContext * ctx, const char * * str_start, guint32 * str_len, const char * * _ptr, const char * end)
{
  const char * ptr.162;
  const char * ptr.163;
  int D.24007;
  gchar * D.24010;
  struct GSList * D.24011;
  struct GSList * D.24012;
  gboolean D.24013;
  char D.24014;
  const char * D.24017;
  int D.24018;
  gchar * D.24023;
  struct GSList * D.24024;
  unsigned int size.164;
  const char * D.24028;
  unsigned int D.24030;
  unsigned int ptr.165;
  gchar * D.24034;
  struct GSList * D.24035;
  guint32 size;
  const char * ptr;

  try
    {
      size = 0;
      ptr.162 = *_ptr;
      ptr = ptr.162;
      *str_start = 0B;
      *str_len = 0;
      ptr.163 = ptr;
      if (ptr.163 >= end) goto <D.24005>; else goto <D.24006>;
      <D.24005>:
      D.24007 = ctx->report_error;
      if (D.24007 != 0) goto <D.24008>; else goto <D.24009>;
      <D.24008>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24010 = monoeg_strdup ("CustomAttribute: Not enough room for string size");
        vinfo->info.message = D.24010;
        vinfo->exception_type = 3;
        D.24011 = ctx->errors;
        D.24012 = monoeg_g_slist_prepend (D.24011, vinfo);
        ctx->errors = D.24012;
      }
      <D.24009>:
      ctx->valid = 0;
      D.24013 = 0;
      return D.24013;
      <D.24006>:
      ptr.163 = ptr;
      D.24014 = *ptr.163;
      if (D.24014 == -1) goto <D.24015>; else goto <D.24016>;
      <D.24015>:
      ptr.163 = ptr;
      D.24017 = ptr.163 + 1;
      *_ptr = D.24017;
      D.24013 = 1;
      return D.24013;
      <D.24016>:
      D.24018 = safe_read_compressed_int (&ptr, end, &size);
      if (D.24018 == 0) goto <D.24019>; else goto <D.24020>;
      <D.24019>:
      D.24007 = ctx->report_error;
      if (D.24007 != 0) goto <D.24021>; else goto <D.24022>;
      <D.24021>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24023 = monoeg_strdup ("CustomAttribute: Not enough room for string size");
        vinfo->info.message = D.24023;
        vinfo->exception_type = 3;
        D.24011 = ctx->errors;
        D.24024 = monoeg_g_slist_prepend (D.24011, vinfo);
        ctx->errors = D.24024;
      }
      <D.24022>:
      ctx->valid = 0;
      D.24013 = 0;
      return D.24013;
      <D.24020>:
      ptr.163 = ptr;
      size.164 = size;
      D.24028 = ptr.163 + size.164;
      if (D.24028 > end) goto <D.24025>; else goto <D.24029>;
      <D.24029>:
      size.164 = size;
      D.24030 = ~size.164;
      ptr.163 = ptr;
      ptr.165 = (unsigned int) ptr.163;
      if (D.24030 < ptr.165) goto <D.24025>; else goto <D.24026>;
      <D.24025>:
      D.24007 = ctx->report_error;
      if (D.24007 != 0) goto <D.24032>; else goto <D.24033>;
      <D.24032>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24034 = monoeg_strdup ("CustomAttribute: Not enough room for string");
        vinfo->info.message = D.24034;
        vinfo->exception_type = 3;
        D.24011 = ctx->errors;
        D.24035 = monoeg_g_slist_prepend (D.24011, vinfo);
        ctx->errors = D.24035;
      }
      <D.24033>:
      ctx->valid = 0;
      D.24013 = 0;
      return D.24013;
      <D.24026>:
      ptr.163 = ptr;
      *str_start = ptr.163;
      size.164 = size;
      *str_len = size.164;
      ptr.163 = ptr;
      size.164 = size;
      D.24028 = ptr.163 + size.164;
      *_ptr = D.24028;
      D.24013 = 1;
      return D.24013;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


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

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


is_valid_fixed_param (struct VerifyContext * ctx, struct MonoType * mono_type, const char * * _ptr, const char * end)
{
  const char * ptr.166;
  unsigned char D.24042;
  const char * ptr.167;
  gboolean D.24044;
  int D.24045;
  int D.24048;
  gchar * D.24051;
  struct GSList * D.24052;
  struct GSList * D.24053;
  unsigned int sub_type.168;
  unsigned int D.24055;
  unsigned char D.24062;
  int D.24067;
  gchar * D.24072;
  struct GSList * D.24073;
  unsigned int etype.169;
  unsigned int etype.170;
  _Bool D.24081;
  _Bool D.24082;
  _Bool D.24083;
  unsigned int etype.171;
  unsigned int D.24088;
  _Bool D.24089;
  _Bool D.24090;
  _Bool D.24091;
  unsigned char iftmp.172;
  gchar * D.24101;
  struct GSList * D.24102;
  gchar * D.24105;
  struct GSList * D.24106;
  struct MonoClass * D.24107;
  const char * D.24112;
  const char * D.24113;
  gchar * D.24114;
  struct GSList * D.24115;
  unsigned char D.24119;
  unsigned char D.24120;
  gchar * D.24123;
  struct GSList * D.24124;
  int D.24125;
  gchar * D.24130;
  struct GSList * D.24131;
  int D.24132;
  gchar * D.24137;
  struct GSList * D.24138;
  unsigned int element_count.173;
  int D.24142;
  gchar * D.24147;
  struct GSList * D.24148;
  sizetype elem_size.174;
  const char * D.24152;
  unsigned int elem_size.175;
  unsigned int D.24155;
  unsigned int ptr.176;
  gchar * D.24159;
  struct GSList * D.24160;
  struct MonoClass * klass;
  const char * ptr;
  int elem_size;
  guint32 element_count;
  guint32 i;
  int type;
  void handle_enum = <<< error >>>;

  try
    {
      ptr.166 = *_ptr;
      ptr = ptr.166;
      elem_size = 0;
      klass = mono_type->data.klass;
      D.24042 = mono_type->type;
      type = (int) D.24042;
      handle_enum:
      switch (type) <default: <D.18171>, case 2: <D.18139>, case 3: <D.18145>, case 4: <D.18140>, case 5: <D.18141>, case 6: <D.18143>, case 7: <D.18144>, case 8: <D.18146>, case 9: <D.18147>, case 10: <D.18149>, case 11: <D.18150>, case 12: <D.18148>, case 13: <D.18151>, case 14: <D.18152>, case 17: <D.18163>, case 18: <D.18161>, case 28: <D.18153>, case 29: <D.18165>>
      <D.18139>:
      <D.18140>:
      <D.18141>:
      elem_size = 1;
      goto <D.18142>;
      <D.18143>:
      <D.18144>:
      <D.18145>:
      elem_size = 2;
      goto <D.18142>;
      <D.18146>:
      <D.18147>:
      <D.18148>:
      elem_size = 4;
      goto <D.18142>;
      <D.18149>:
      <D.18150>:
      <D.18151>:
      elem_size = 8;
      goto <D.18142>;
      <D.18152>:
      ptr.167 = ptr;
      *_ptr = ptr.167;
      D.24044 = is_valid_ser_string (ctx, _ptr, end);
      return D.24044;
      <D.18153>:
      {
        unsigned int sub_type;

        try
          {
            sub_type = 0;
            D.24045 = safe_read (&ptr, end, &sub_type, 1);
            if (D.24045 == 0) goto <D.24046>; else goto <D.24047>;
            <D.24046>:
            D.24048 = ctx->report_error;
            if (D.24048 != 0) goto <D.24049>; else goto <D.24050>;
            <D.24049>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.24051 = monoeg_strdup ("CustomAttribute: Not enough room for array type");
              vinfo->info.message = D.24051;
              vinfo->exception_type = 3;
              D.24052 = ctx->errors;
              D.24053 = monoeg_g_slist_prepend (D.24052, vinfo);
              ctx->errors = D.24053;
            }
            <D.24050>:
            ctx->valid = 0;
            D.24044 = 0;
            return D.24044;
            <D.24047>:
            sub_type.168 = sub_type;
            D.24055 = sub_type.168 + 4294967294;
            if (D.24055 <= 12) goto <D.24056>; else goto <D.24057>;
            <D.24056>:
            sub_type.168 = sub_type;
            type = (int) sub_type.168;
            goto handle_enum;
            <D.24057>:
            sub_type.168 = sub_type;
            if (sub_type.168 == 85) goto <D.24058>; else goto <D.24059>;
            <D.24058>:
            klass = get_enum_by_encoded_name (ctx, &ptr, end);
            if (klass == 0B) goto <D.24060>; else goto <D.24061>;
            <D.24060>:
            D.24044 = 0;
            return D.24044;
            <D.24061>:
            klass = klass->element_class;
            D.24062 = klass->byval_arg.type;
            type = (int) D.24062;
            goto handle_enum;
            <D.24059>:
            sub_type.168 = sub_type;
            if (sub_type.168 == 80) goto <D.24063>; else goto <D.24064>;
            <D.24063>:
            ptr.167 = ptr;
            *_ptr = ptr.167;
            D.24044 = is_valid_ser_string (ctx, _ptr, end);
            return D.24044;
            <D.24064>:
            sub_type.168 = sub_type;
            if (sub_type.168 == 29) goto <D.24065>; else goto <D.24066>;
            <D.24065>:
            {
              struct MonoType simple_type;
              unsigned int etype;

              try
                {
                  simple_type = {};
                  etype = 0;
                  D.24067 = safe_read (&ptr, end, &etype, 1);
                  if (D.24067 == 0) goto <D.24068>; else goto <D.24069>;
                  <D.24068>:
                  D.24048 = ctx->report_error;
                  if (D.24048 != 0) goto <D.24070>; else goto <D.24071>;
                  <D.24070>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (12);
                    vinfo->info.status = 1;
                    D.24072 = monoeg_strdup ("CustomAttribute: Not enough room for array element type");
                    vinfo->info.message = D.24072;
                    vinfo->exception_type = 3;
                    D.24052 = ctx->errors;
                    D.24073 = monoeg_g_slist_prepend (D.24052, vinfo);
                    ctx->errors = D.24073;
                  }
                  <D.24071>:
                  ctx->valid = 0;
                  D.24044 = 0;
                  return D.24044;
                  <D.24069>:
                  etype.169 = etype;
                  if (etype.169 == 85) goto <D.24075>; else goto <D.24076>;
                  <D.24075>:
                  klass = get_enum_by_encoded_name (ctx, &ptr, end);
                  if (klass == 0B) goto <D.24077>; else goto <D.24078>;
                  <D.24077>:
                  D.24044 = 0;
                  return D.24044;
                  <D.24078>:
                  goto <D.24079>;
                  <D.24076>:
                  etype.170 = etype;
                  D.24081 = etype.170 == 80;
                  D.24082 = etype.170 == 18;
                  D.24083 = D.24081 | D.24082;
                  if (D.24083 != 0) goto <D.24084>; else goto <D.24085>;
                  <D.24084>:
                  klass = mono_defaults.systemtype_class;
                  goto <D.24086>;
                  <D.24085>:
                  etype.171 = etype;
                  D.24088 = etype.171 + 4294967294;
                  D.24089 = D.24088 <= 12;
                  D.24090 = etype.171 == 81;
                  D.24091 = D.24089 | D.24090;
                  if (D.24091 != 0) goto <D.24092>; else goto <D.24093>;
                  <D.24092>:
                  etype.169 = etype;
                  if (etype.169 != 81) goto <D.24095>; else goto <D.24096>;
                  <D.24095>:
                  etype.169 = etype;
                  iftmp.172 = (unsigned char) etype.169;
                  goto <D.24097>;
                  <D.24096>:
                  iftmp.172 = 28;
                  <D.24097>:
                  simple_type.type = iftmp.172;
                  klass = mono_class_from_mono_type (&simple_type);
                  goto <D.24098>;
                  <D.24093>:
                  D.24048 = ctx->report_error;
                  if (D.24048 != 0) goto <D.24099>; else goto <D.24100>;
                  <D.24099>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (12);
                    vinfo->info.status = 1;
                    etype.169 = etype;
                    D.24101 = monoeg_g_strdup_printf ("CustomAttribute: Invalid array element type %x", etype.169);
                    vinfo->info.message = D.24101;
                    vinfo->exception_type = 3;
                    D.24052 = ctx->errors;
                    D.24102 = monoeg_g_slist_prepend (D.24052, vinfo);
                    ctx->errors = D.24102;
                  }
                  <D.24100>:
                  ctx->valid = 0;
                  D.24044 = 0;
                  return D.24044;
                  <D.24098>:
                  <D.24086>:
                  <D.24079>:
                  type = 29;
                  goto handle_enum;
                }
              finally
                {
                  simple_type = {CLOBBER};
                  etype = {CLOBBER};
                }
            }
            <D.24066>:
            D.24048 = ctx->report_error;
            if (D.24048 != 0) goto <D.24103>; else goto <D.24104>;
            <D.24103>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              sub_type.168 = sub_type;
              D.24105 = monoeg_g_strdup_printf ("CustomAttribute: Invalid boxed object type %x", sub_type.168);
              vinfo->info.message = D.24105;
              vinfo->exception_type = 3;
              D.24052 = ctx->errors;
              D.24106 = monoeg_g_slist_prepend (D.24052, vinfo);
              ctx->errors = D.24106;
            }
            <D.24104>:
            ctx->valid = 0;
            D.24044 = 0;
            return D.24044;
          }
        finally
          {
            sub_type = {CLOBBER};
          }
      }
      <D.18161>:
      D.24107 = mono_defaults.systemtype_class;
      if (D.24107 != klass) goto <D.24108>; else goto <D.24109>;
      <D.24108>:
      D.24048 = ctx->report_error;
      if (D.24048 != 0) goto <D.24110>; else goto <D.24111>;
      <D.24110>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24112 = klass->name;
        D.24113 = klass->name_space;
        D.24114 = monoeg_g_strdup_printf ("CustomAttribute: Invalid class parameter type %s:%s ", D.24113, D.24112);
        vinfo->info.message = D.24114;
        vinfo->exception_type = 3;
        D.24052 = ctx->errors;
        D.24115 = monoeg_g_slist_prepend (D.24052, vinfo);
        ctx->errors = D.24115;
      }
      <D.24111>:
      ctx->valid = 0;
      D.24044 = 0;
      return D.24044;
      <D.24109>:
      ptr.167 = ptr;
      *_ptr = ptr.167;
      D.24044 = is_valid_ser_string (ctx, _ptr, end);
      return D.24044;
      <D.18163>:
      if (klass == 0B) goto <D.24116>; else goto <D.24118>;
      <D.24118>:
      D.24119 = BIT_FIELD_REF <*klass, 8, 160>;
      D.24120 = D.24119 & 16;
      if (D.24120 == 0) goto <D.24116>; else goto <D.24117>;
      <D.24116>:
      D.24048 = ctx->report_error;
      if (D.24048 != 0) goto <D.24121>; else goto <D.24122>;
      <D.24121>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24112 = klass->name;
        D.24113 = klass->name_space;
        D.24123 = monoeg_g_strdup_printf ("CustomAttribute: Invalid valuetype parameter expected enum %s:%s ", D.24113, D.24112);
        vinfo->info.message = D.24123;
        vinfo->exception_type = 3;
        D.24052 = ctx->errors;
        D.24124 = monoeg_g_slist_prepend (D.24052, vinfo);
        ctx->errors = D.24124;
      }
      <D.24122>:
      ctx->valid = 0;
      D.24044 = 0;
      return D.24044;
      <D.24117>:
      klass = klass->element_class;
      D.24062 = klass->byval_arg.type;
      type = (int) D.24062;
      goto handle_enum;
      <D.18165>:
      mono_type = &klass->byval_arg;
      D.24125 = is_valid_cattr_type (mono_type);
      if (D.24125 == 0) goto <D.24126>; else goto <D.24127>;
      <D.24126>:
      D.24048 = ctx->report_error;
      if (D.24048 != 0) goto <D.24128>; else goto <D.24129>;
      <D.24128>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24112 = klass->name;
        D.24113 = klass->name_space;
        D.24130 = monoeg_g_strdup_printf ("CustomAttribute: Invalid array element type %s:%s ", D.24113, D.24112);
        vinfo->info.message = D.24130;
        vinfo->exception_type = 3;
        D.24052 = ctx->errors;
        D.24131 = monoeg_g_slist_prepend (D.24052, vinfo);
        ctx->errors = D.24131;
      }
      <D.24129>:
      ctx->valid = 0;
      D.24044 = 0;
      return D.24044;
      <D.24127>:
      D.24132 = safe_read (&ptr, end, &element_count, 4);
      if (D.24132 == 0) goto <D.24133>; else goto <D.24134>;
      <D.24133>:
      D.24048 = ctx->report_error;
      if (D.24048 != 0) goto <D.24135>; else goto <D.24136>;
      <D.24135>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24112 = klass->name;
        D.24113 = klass->name_space;
        D.24137 = monoeg_g_strdup_printf ("CustomAttribute: Invalid class parameter type %s:%s ", D.24113, D.24112);
        vinfo->info.message = D.24137;
        vinfo->exception_type = 3;
        D.24052 = ctx->errors;
        D.24138 = monoeg_g_slist_prepend (D.24052, vinfo);
        ctx->errors = D.24138;
      }
      <D.24136>:
      ctx->valid = 0;
      D.24044 = 0;
      return D.24044;
      <D.24134>:
      element_count.173 = element_count;
      if (element_count.173 == 4294967295) goto <D.24140>; else goto <D.24141>;
      <D.24140>:
      ptr.167 = ptr;
      *_ptr = ptr.167;
      D.24044 = 1;
      return D.24044;
      <D.24141>:
      i = 0;
      goto <D.18169>;
      <D.18168>:
      D.24142 = is_valid_fixed_param (ctx, mono_type, &ptr, end);
      if (D.24142 == 0) goto <D.24143>; else goto <D.24144>;
      <D.24143>:
      D.24044 = 0;
      return D.24044;
      <D.24144>:
      i = i + 1;
      <D.18169>:
      element_count.173 = element_count;
      if (i < element_count.173) goto <D.18168>; else goto <D.18170>;
      <D.18170>:
      ptr.167 = ptr;
      *_ptr = ptr.167;
      D.24044 = 1;
      return D.24044;
      <D.18171>:
      D.24048 = ctx->report_error;
      if (D.24048 != 0) goto <D.24145>; else goto <D.24146>;
      <D.24145>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24147 = monoeg_g_strdup_printf ("CustomAttribute: Invalid parameter type %x ", type);
        vinfo->info.message = D.24147;
        vinfo->exception_type = 3;
        D.24052 = ctx->errors;
        D.24148 = monoeg_g_slist_prepend (D.24052, vinfo);
        ctx->errors = D.24148;
      }
      <D.24146>:
      ctx->valid = 0;
      D.24044 = 0;
      return D.24044;
      <D.18142>:
      ptr.167 = ptr;
      elem_size.174 = (sizetype) elem_size;
      D.24152 = ptr.167 + elem_size.174;
      if (D.24152 > end) goto <D.24149>; else goto <D.24153>;
      <D.24153>:
      elem_size.175 = (unsigned int) elem_size;
      D.24155 = ~elem_size.175;
      ptr.167 = ptr;
      ptr.176 = (unsigned int) ptr.167;
      if (D.24155 < ptr.176) goto <D.24149>; else goto <D.24150>;
      <D.24149>:
      D.24048 = ctx->report_error;
      if (D.24048 != 0) goto <D.24157>; else goto <D.24158>;
      <D.24157>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24159 = monoeg_strdup ("CustomAttribute: Not enough space for element");
        vinfo->info.message = D.24159;
        vinfo->exception_type = 3;
        D.24052 = ctx->errors;
        D.24160 = monoeg_g_slist_prepend (D.24052, vinfo);
        ctx->errors = D.24160;
      }
      <D.24158>:
      ctx->valid = 0;
      D.24044 = 0;
      return D.24044;
      <D.24150>:
      ptr.167 = ptr;
      elem_size.174 = (sizetype) elem_size;
      D.24152 = ptr.167 + elem_size.174;
      *_ptr = D.24152;
      D.24044 = 1;
      return D.24044;
    }
  finally
    {
      ptr = {CLOBBER};
      element_count = {CLOBBER};
    }
}


is_valid_cattr_type (struct MonoType * type)
{
  unsigned char D.24167;
  _Bool D.24168;
  unsigned char D.24169;
  _Bool D.24170;
  _Bool D.24171;
  gboolean D.24174;
  unsigned char D.24175;
  int iftmp.177;
  unsigned char D.24182;
  unsigned char D.24183;
  struct MonoClass * D.24187;
  struct MonoClass * D.24188;
  _Bool D.24189;
  struct MonoClass * klass;

  D.24167 = type->type;
  D.24168 = D.24167 == 28;
  D.24169 = D.24167 + 254;
  D.24170 = D.24169 <= 12;
  D.24171 = D.24168 | D.24170;
  if (D.24171 != 0) goto <D.24172>; else goto <D.24173>;
  <D.24172>:
  D.24174 = 1;
  return D.24174;
  <D.24173>:
  D.24175 = type->type;
  if (D.24175 == 17) goto <D.24176>; else goto <D.24177>;
  <D.24176>:
  klass = mono_class_from_mono_type (type);
  if (klass != 0B) goto <D.24181>; else goto <D.24179>;
  <D.24181>:
  D.24182 = BIT_FIELD_REF <*klass, 8, 160>;
  D.24183 = D.24182 & 16;
  if (D.24183 != 0) goto <D.24184>; else goto <D.24179>;
  <D.24184>:
  iftmp.177 = 1;
  goto <D.24180>;
  <D.24179>:
  iftmp.177 = 0;
  <D.24180>:
  D.24174 = iftmp.177;
  return D.24174;
  <D.24177>:
  D.24175 = type->type;
  if (D.24175 == 18) goto <D.24185>; else goto <D.24186>;
  <D.24185>:
  D.24187 = mono_class_from_mono_type (type);
  D.24188 = mono_defaults.systemtype_class;
  D.24189 = D.24187 == D.24188;
  D.24174 = (gboolean) D.24189;
  return D.24174;
  <D.24186>:
  D.24174 = 0;
  return D.24174;
}


verify_field_marshal_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24191;
  unsigned int D.24192;
  int D.24193;
  int D.24196;
  gchar * D.24199;
  struct GSList * D.24200;
  struct GSList * D.24201;
  <unnamed-unsigned:24> D.24202;
  int D.24203;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.24191 = ctx->image;
      table = &D.24191->tables[13];
      i = 0;
      goto <D.18675>;
      <D.18674>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.24192 = data[1];
      D.24193 = is_valid_marshal_spec (ctx, D.24192);
      if (D.24193 == 0) goto <D.24194>; else goto <D.24195>;
      <D.24194>:
      D.24196 = ctx->report_error;
      if (D.24196 != 0) goto <D.24197>; else goto <D.24198>;
      <D.24197>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24192 = data[1];
        D.24199 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d NativeType field 0x%08x", i, D.24192);
        vinfo->info.message = D.24199;
        vinfo->exception_type = 3;
        D.24200 = ctx->errors;
        D.24201 = monoeg_g_slist_prepend (D.24200, vinfo);
        ctx->errors = D.24201;
      }
      <D.24198>:
      ctx->valid = 0;
      return;
      <D.24195>:
      i = i + 1;
      <D.18675>:
      D.24202 = table->rows;
      D.24203 = (int) D.24202;
      if (D.24203 > i) goto <D.18674>; else goto <D.18676>;
      <D.18676>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_marshal_spec (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.24207;
  struct MonoStreamHeader * D.24208;
  gboolean D.24209;
  int iftmp.178;
  unsigned int D.24213;
  unsigned int D.24215;
  struct OffsetAndSize blob;

  try
    {
      D.24207 = ctx->image;
      D.24208 = &D.24207->heap_blob;
      blob = get_metadata_stream (ctx, D.24208); [return slot optimization]
      D.24213 = blob.size;
      if (D.24213 != 0) goto <D.24214>; else goto <D.24211>;
      <D.24214>:
      D.24213 = blob.size;
      D.24215 = D.24213 + 4294967295;
      if (D.24215 >= offset) goto <D.24216>; else goto <D.24211>;
      <D.24216>:
      iftmp.178 = 1;
      goto <D.24212>;
      <D.24211>:
      iftmp.178 = 0;
      <D.24212>:
      D.24209 = iftmp.178;
      return D.24209;
    }
  finally
    {
      blob = {CLOBBER};
    }
}


verify_decl_security_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24219;
  unsigned int D.24220;
  int D.24221;
  int D.24224;
  gchar * D.24227;
  struct GSList * D.24228;
  struct GSList * D.24229;
  <unnamed-unsigned:24> D.24230;
  int D.24231;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.24219 = ctx->image;
      table = &D.24219->tables[14];
      i = 0;
      goto <D.18697>;
      <D.18696>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.24220 = data[2];
      D.24221 = is_valid_permission_set (ctx, D.24220);
      if (D.24221 == 0) goto <D.24222>; else goto <D.24223>;
      <D.24222>:
      D.24224 = ctx->report_error;
      if (D.24224 != 0) goto <D.24225>; else goto <D.24226>;
      <D.24225>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24220 = data[2];
        D.24227 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d PermissionSet field 0x%08x", i, D.24220);
        vinfo->info.message = D.24227;
        vinfo->exception_type = 3;
        D.24228 = ctx->errors;
        D.24229 = monoeg_g_slist_prepend (D.24228, vinfo);
        ctx->errors = D.24229;
      }
      <D.24226>:
      ctx->valid = 0;
      return;
      <D.24223>:
      i = i + 1;
      <D.18697>:
      D.24230 = table->rows;
      D.24231 = (int) D.24230;
      if (D.24231 > i) goto <D.18696>; else goto <D.18698>;
      <D.18698>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_permission_set (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.24235;
  struct MonoStreamHeader * D.24236;
  gboolean D.24237;
  int iftmp.179;
  unsigned int D.24241;
  unsigned int D.24243;
  struct OffsetAndSize blob;

  try
    {
      D.24235 = ctx->image;
      D.24236 = &D.24235->heap_blob;
      blob = get_metadata_stream (ctx, D.24236); [return slot optimization]
      D.24241 = blob.size;
      if (D.24241 != 0) goto <D.24242>; else goto <D.24239>;
      <D.24242>:
      D.24241 = blob.size;
      D.24243 = D.24241 + 4294967295;
      if (D.24243 >= offset) goto <D.24244>; else goto <D.24239>;
      <D.24244>:
      iftmp.179 = 1;
      goto <D.24240>;
      <D.24239>:
      iftmp.179 = 0;
      <D.24240>:
      D.24237 = iftmp.179;
      return D.24237;
    }
  finally
    {
      blob = {CLOBBER};
    }
}


verify_standalonesig_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24247;
  unsigned int D.24248;
  int D.24249;
  int D.24252;
  gchar * D.24255;
  struct GSList * D.24256;
  struct GSList * D.24257;
  <unnamed-unsigned:24> D.24258;
  int D.24259;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.24247 = ctx->image;
      table = &D.24247->tables[17];
      i = 0;
      goto <D.18749>;
      <D.18748>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.24248 = data[0];
      D.24249 = is_valid_standalonesig_blob (ctx, D.24248);
      if (D.24249 == 0) goto <D.24250>; else goto <D.24251>;
      <D.24250>:
      D.24252 = ctx->report_error;
      if (D.24252 != 0) goto <D.24253>; else goto <D.24254>;
      <D.24253>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24248 = data[0];
        D.24255 = monoeg_g_strdup_printf ("Invalid StandAloneSig row %d Signature field 0x%08x", i, D.24248);
        vinfo->info.message = D.24255;
        vinfo->exception_type = 3;
        D.24256 = ctx->errors;
        D.24257 = monoeg_g_slist_prepend (D.24256, vinfo);
        ctx->errors = D.24257;
      }
      <D.24254>:
      ctx->valid = 0;
      return;
      <D.24251>:
      i = i + 1;
      <D.18749>:
      D.24258 = table->rows;
      D.24259 = (int) D.24258;
      if (D.24259 > i) goto <D.18748>; else goto <D.18750>;
      <D.18750>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_standalonesig_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.24263;
  int D.24266;
  gchar * D.24269;
  struct GSList * D.24270;
  struct GSList * D.24271;
  gboolean D.24272;
  const char * ptr.180;
  unsigned int size.181;
  int D.24275;
  gchar * D.24280;
  struct GSList * D.24281;
  const char * ptr.182;
  unsigned int signature.183;
  guint32 size;
  unsigned int signature;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      signature = 0;
      ptr = 0B;
      D.24263 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.24263 == 0) goto <D.24264>; else goto <D.24265>;
      <D.24264>:
      D.24266 = ctx->report_error;
      if (D.24266 != 0) goto <D.24267>; else goto <D.24268>;
      <D.24267>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24269 = monoeg_strdup ("StandAloneSig: Could not decode signature header");
        vinfo->info.message = D.24269;
        vinfo->exception_type = 3;
        D.24270 = ctx->errors;
        D.24271 = monoeg_g_slist_prepend (D.24270, vinfo);
        ctx->errors = D.24271;
      }
      <D.24268>:
      ctx->valid = 0;
      D.24272 = 0;
      return D.24272;
      <D.24265>:
      ptr.180 = ptr;
      size.181 = size;
      end = ptr.180 + size.181;
      D.24275 = safe_read (&ptr, end, &signature, 1);
      if (D.24275 == 0) goto <D.24276>; else goto <D.24277>;
      <D.24276>:
      D.24266 = ctx->report_error;
      if (D.24266 != 0) goto <D.24278>; else goto <D.24279>;
      <D.24278>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24280 = monoeg_strdup ("StandAloneSig: Not enough room for the call conv");
        vinfo->info.message = D.24280;
        vinfo->exception_type = 3;
        D.24270 = ctx->errors;
        D.24281 = monoeg_g_slist_prepend (D.24270, vinfo);
        ctx->errors = D.24281;
      }
      <D.24279>:
      ctx->valid = 0;
      D.24272 = 0;
      return D.24272;
      <D.24277>:
      ptr.180 = ptr;
      ptr.182 = ptr.180 + 4294967295;
      ptr = ptr.182;
      signature.183 = signature;
      if (signature.183 == 7) goto <D.24284>; else goto <D.24285>;
      <D.24284>:
      D.24272 = parse_locals_signature (ctx, &ptr, end);
      return D.24272;
      <D.24285>:
      signature.183 = signature;
      if (signature.183 == 6) goto <D.24286>; else goto <D.24287>;
      <D.24286>:
      D.24272 = parse_field (ctx, &ptr, end);
      return D.24272;
      <D.24287>:
      D.24272 = parse_method_signature (ctx, &ptr, end, 1, 1);
      return D.24272;
    }
  finally
    {
      size = {CLOBBER};
      signature = {CLOBBER};
      ptr = {CLOBBER};
    }
}


parse_locals_signature (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.184;
  int D.24291;
  int D.24294;
  gchar * D.24297;
  struct GSList * D.24298;
  struct GSList * D.24299;
  gboolean D.24300;
  unsigned int sig.185;
  gchar * D.24306;
  struct GSList * D.24307;
  int D.24308;
  gchar * D.24313;
  struct GSList * D.24314;
  int D.24315;
  gchar * D.24320;
  struct GSList * D.24321;
  int D.24324;
  gchar * D.24329;
  struct GSList * D.24330;
  int D.24331;
  gchar * D.24336;
  struct GSList * D.24337;
  unsigned int sig.186;
  unsigned int D.24339;
  _Bool D.24340;
  _Bool D.24341;
  _Bool D.24342;
  int D.24345;
  gchar * D.24350;
  struct GSList * D.24351;
  gchar * D.24356;
  struct GSList * D.24357;
  const char * ptr.187;
  const char * ptr.188;
  int D.24362;
  gchar * D.24367;
  struct GSList * D.24368;
  unsigned int locals_count.189;
  unsigned int sig;
  unsigned int locals_count;
  unsigned int i;
  const char * ptr;

  try
    {
      sig = 0;
      locals_count = 0;
      ptr.184 = *_ptr;
      ptr = ptr.184;
      D.24291 = safe_read (&ptr, end, &sig, 1);
      if (D.24291 == 0) goto <D.24292>; else goto <D.24293>;
      <D.24292>:
      D.24294 = ctx->report_error;
      if (D.24294 != 0) goto <D.24295>; else goto <D.24296>;
      <D.24295>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24297 = monoeg_strdup ("LocalsSig: Not enough room for signature");
        vinfo->info.message = D.24297;
        vinfo->exception_type = 3;
        D.24298 = ctx->errors;
        D.24299 = monoeg_g_slist_prepend (D.24298, vinfo);
        ctx->errors = D.24299;
      }
      <D.24296>:
      ctx->valid = 0;
      D.24300 = 0;
      return D.24300;
      <D.24293>:
      sig.185 = sig;
      if (sig.185 != 7) goto <D.24302>; else goto <D.24303>;
      <D.24302>:
      D.24294 = ctx->report_error;
      if (D.24294 != 0) goto <D.24304>; else goto <D.24305>;
      <D.24304>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        sig.185 = sig;
        D.24306 = monoeg_g_strdup_printf ("LocalsSig: Signature is not 0x28 or 0x08: %x", sig.185);
        vinfo->info.message = D.24306;
        vinfo->exception_type = 3;
        D.24298 = ctx->errors;
        D.24307 = monoeg_g_slist_prepend (D.24298, vinfo);
        ctx->errors = D.24307;
      }
      <D.24305>:
      ctx->valid = 0;
      D.24300 = 0;
      return D.24300;
      <D.24303>:
      D.24308 = safe_read_compressed_int (&ptr, end, &locals_count);
      if (D.24308 == 0) goto <D.24309>; else goto <D.24310>;
      <D.24309>:
      D.24294 = ctx->report_error;
      if (D.24294 != 0) goto <D.24311>; else goto <D.24312>;
      <D.24311>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24313 = monoeg_strdup ("LocalsSig: Not enough room for the param count");
        vinfo->info.message = D.24313;
        vinfo->exception_type = 3;
        D.24298 = ctx->errors;
        D.24314 = monoeg_g_slist_prepend (D.24298, vinfo);
        ctx->errors = D.24314;
      }
      <D.24312>:
      ctx->valid = 0;
      D.24300 = 0;
      return D.24300;
      <D.24310>:
      i = 0;
      goto <D.18039>;
      <D.18038>:
      D.24315 = safe_read (&ptr, end, &sig, 1);
      if (D.24315 == 0) goto <D.24316>; else goto <D.24317>;
      <D.24316>:
      D.24294 = ctx->report_error;
      if (D.24294 != 0) goto <D.24318>; else goto <D.24319>;
      <D.24318>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24320 = monoeg_strdup ("LocalsSig: Not enough room for type");
        vinfo->info.message = D.24320;
        vinfo->exception_type = 3;
        D.24298 = ctx->errors;
        D.24321 = monoeg_g_slist_prepend (D.24298, vinfo);
        ctx->errors = D.24321;
      }
      <D.24319>:
      ctx->valid = 0;
      D.24300 = 0;
      return D.24300;
      <D.24317>:
      goto <D.18032>;
      <D.18031>:
      sig.185 = sig;
      if (sig.185 != 69) goto <D.24322>; else goto <D.24323>;
      <D.24322>:
      D.24324 = parse_custom_mods (ctx, &ptr, end);
      if (D.24324 == 0) goto <D.24325>; else goto <D.24326>;
      <D.24325>:
      D.24294 = ctx->report_error;
      if (D.24294 != 0) goto <D.24327>; else goto <D.24328>;
      <D.24327>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24329 = monoeg_g_strdup_printf ("LocalsSig: Error parsing local %d", i);
        vinfo->info.message = D.24329;
        vinfo->exception_type = 3;
        D.24298 = ctx->errors;
        D.24330 = monoeg_g_slist_prepend (D.24298, vinfo);
        ctx->errors = D.24330;
      }
      <D.24328>:
      ctx->valid = 0;
      D.24300 = 0;
      return D.24300;
      <D.24326>:
      <D.24323>:
      D.24331 = safe_read (&ptr, end, &sig, 1);
      if (D.24331 == 0) goto <D.24332>; else goto <D.24333>;
      <D.24332>:
      D.24294 = ctx->report_error;
      if (D.24294 != 0) goto <D.24334>; else goto <D.24335>;
      <D.24334>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24336 = monoeg_strdup ("LocalsSig: Not enough room for type");
        vinfo->info.message = D.24336;
        vinfo->exception_type = 3;
        D.24298 = ctx->errors;
        D.24337 = monoeg_g_slist_prepend (D.24298, vinfo);
        ctx->errors = D.24337;
      }
      <D.24335>:
      ctx->valid = 0;
      D.24300 = 0;
      return D.24300;
      <D.24333>:
      <D.18032>:
      sig.186 = sig;
      D.24339 = sig.186 + 4294967265;
      D.24340 = D.24339 <= 1;
      D.24341 = sig.186 == 69;
      D.24342 = D.24340 | D.24341;
      if (D.24342 != 0) goto <D.18031>; else goto <D.18033>;
      <D.18033>:
      sig.185 = sig;
      if (sig.185 == 16) goto <D.24343>; else goto <D.24344>;
      <D.24343>:
      D.24345 = safe_read (&ptr, end, &sig, 1);
      if (D.24345 == 0) goto <D.24346>; else goto <D.24347>;
      <D.24346>:
      D.24294 = ctx->report_error;
      if (D.24294 != 0) goto <D.24348>; else goto <D.24349>;
      <D.24348>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24350 = monoeg_g_strdup_printf ("Type: Not enough room for byref type for local %d", i);
        vinfo->info.message = D.24350;
        vinfo->exception_type = 3;
        D.24298 = ctx->errors;
        D.24351 = monoeg_g_slist_prepend (D.24298, vinfo);
        ctx->errors = D.24351;
      }
      <D.24349>:
      ctx->valid = 0;
      D.24300 = 0;
      return D.24300;
      <D.24347>:
      sig.185 = sig;
      if (sig.185 == 22) goto <D.24352>; else goto <D.24353>;
      <D.24352>:
      D.24294 = ctx->report_error;
      if (D.24294 != 0) goto <D.24354>; else goto <D.24355>;
      <D.24354>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24356 = monoeg_g_strdup_printf ("Type: Invalid type typedref& for local %d", i);
        vinfo->info.message = D.24356;
        vinfo->exception_type = 3;
        D.24298 = ctx->errors;
        D.24357 = monoeg_g_slist_prepend (D.24298, vinfo);
        ctx->errors = D.24357;
      }
      <D.24355>:
      ctx->valid = 0;
      D.24300 = 0;
      return D.24300;
      <D.24353>:
      <D.24344>:
      sig.185 = sig;
      if (sig.185 == 22) goto <D.24358>; else goto <D.24359>;
      <D.24358>:
      // predicted unlikely by continue predictor.
      goto <D.18036>;
      <D.24359>:
      ptr.187 = ptr;
      ptr.188 = ptr.187 + 4294967295;
      ptr = ptr.188;
      D.24362 = parse_type (ctx, &ptr, end);
      if (D.24362 == 0) goto <D.24363>; else goto <D.24364>;
      <D.24363>:
      D.24294 = ctx->report_error;
      if (D.24294 != 0) goto <D.24365>; else goto <D.24366>;
      <D.24365>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24367 = monoeg_g_strdup_printf ("LocalsSig: Error parsing local %d", i);
        vinfo->info.message = D.24367;
        vinfo->exception_type = 3;
        D.24298 = ctx->errors;
        D.24368 = monoeg_g_slist_prepend (D.24298, vinfo);
        ctx->errors = D.24368;
      }
      <D.24366>:
      ctx->valid = 0;
      D.24300 = 0;
      return D.24300;
      <D.24364>:
      <D.18036>:
      i = i + 1;
      <D.18039>:
      locals_count.189 = locals_count;
      if (i < locals_count.189) goto <D.18038>; else goto <D.18040>;
      <D.18040>:
      ptr.187 = ptr;
      *_ptr = ptr.187;
      D.24300 = 1;
      return D.24300;
    }
  finally
    {
      sig = {CLOBBER};
      locals_count = {CLOBBER};
      ptr = {CLOBBER};
    }
}


verify_event_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24372;
  unsigned int i.190;
  int D.24376;
  gchar * D.24379;
  struct GSList * D.24380;
  struct GSList * D.24381;
  int D.24382;
  unsigned int D.24383;
  unsigned int D.24385;
  unsigned int D.24387;
  unsigned int D.24388;
  unsigned int D.24391;
  _Bool D.24394;
  _Bool D.24395;
  _Bool D.24396;
  <unnamed-unsigned:24> D.24398;
  int D.24399;
  gchar * D.24404;
  struct GSList * D.24405;
  gchar * D.24410;
  struct GSList * D.24411;
  <unnamed-unsigned:24> D.24412;
  int D.24413;
  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.24372 = ctx->image;
      table = &D.24372->tables[20];
      D.24372 = ctx->image;
      sema_table = &D.24372->tables[24];
      i = 0;
      goto <D.18797>;
      <D.18796>:
      mono_metadata_decode_row (table, i, &data, 3);
      i.190 = (unsigned int) i;
      token = make_coded_token (48, 20, i.190);
      idx = search_sorted_table (ctx, 24, 2, token);
      if (idx == -1) goto <D.24374>; else goto <D.24375>;
      <D.24374>:
      D.24376 = ctx->report_error;
      if (D.24376 != 0) goto <D.24377>; else goto <D.24378>;
      <D.24377>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24379 = monoeg_g_strdup_printf ("Invalid Event row %d has no AddOn or RemoveOn associated methods", i);
        vinfo->info.message = D.24379;
        vinfo->exception_type = 3;
        D.24380 = ctx->errors;
        D.24381 = monoeg_g_slist_prepend (D.24380, vinfo);
        ctx->errors = D.24381;
      }
      <D.24378>:
      ctx->valid = 0;
      return;
      <D.24375>:
      goto <D.18790>;
      <D.18789>:
      D.24382 = idx + -1;
      D.24383 = mono_metadata_decode_row_col (sema_table, D.24382, 2);
      if (D.24383 != token) goto <D.18788>; else goto <D.24384>;
      <D.24384>:
      idx = idx + -1;
      <D.18790>:
      if (idx > 0) goto <D.18789>; else goto <D.18788>;
      <D.18788>:
      found_remove = 0;
      found_add = found_remove;
      goto <D.18793>;
      <D.18792>:
      mono_metadata_decode_row (sema_table, idx, &sema_data, 3);
      D.24385 = sema_data[2];
      if (D.24385 != token) goto <D.18791>; else goto <D.24386>;
      <D.24386>:
      D.24387 = sema_data[0];
      D.24388 = D.24387 & 8;
      if (D.24388 != 0) goto <D.24389>; else goto <D.24390>;
      <D.24389>:
      found_add = 1;
      <D.24390>:
      D.24387 = sema_data[0];
      D.24391 = D.24387 & 16;
      if (D.24391 != 0) goto <D.24392>; else goto <D.24393>;
      <D.24392>:
      found_remove = 1;
      <D.24393>:
      D.24394 = found_add != 0;
      D.24395 = found_remove != 0;
      D.24396 = D.24394 & D.24395;
      if (D.24396 != 0) goto <D.18791>; else goto <D.24397>;
      <D.24397>:
      idx = idx + 1;
      <D.18793>:
      D.24398 = sema_table->rows;
      D.24399 = (int) D.24398;
      if (D.24399 > idx) goto <D.18792>; else goto <D.18791>;
      <D.18791>:
      if (found_add == 0) goto <D.24400>; else goto <D.24401>;
      <D.24400>:
      D.24376 = ctx->report_error;
      if (D.24376 != 0) goto <D.24402>; else goto <D.24403>;
      <D.24402>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24404 = monoeg_g_strdup_printf ("Invalid Event row %d has no AddOn associated method", i);
        vinfo->info.message = D.24404;
        vinfo->exception_type = 3;
        D.24380 = ctx->errors;
        D.24405 = monoeg_g_slist_prepend (D.24380, vinfo);
        ctx->errors = D.24405;
      }
      <D.24403>:
      ctx->valid = 0;
      return;
      <D.24401>:
      if (found_remove == 0) goto <D.24406>; else goto <D.24407>;
      <D.24406>:
      D.24376 = ctx->report_error;
      if (D.24376 != 0) goto <D.24408>; else goto <D.24409>;
      <D.24408>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24410 = monoeg_g_strdup_printf ("Invalid Event row %d has no RemoveOn associated method", i);
        vinfo->info.message = D.24410;
        vinfo->exception_type = 3;
        D.24380 = ctx->errors;
        D.24411 = monoeg_g_slist_prepend (D.24380, vinfo);
        ctx->errors = D.24411;
      }
      <D.24409>:
      ctx->valid = 0;
      return;
      <D.24407>:
      i = i + 1;
      <D.18797>:
      D.24412 = table->rows;
      D.24413 = (int) D.24412;
      if (D.24413 > i) goto <D.18796>; else goto <D.18798>;
      <D.18798>:
    }
  finally
    {
      data = {CLOBBER};
      sema_data = {CLOBBER};
    }
}


verify_typespec_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24417;
  int D.24418;
  int D.24419;
  unsigned int D.24420;
  unsigned int D.24421;
  int D.24422;
  int D.24425;
  gchar * D.24428;
  struct GSList * D.24429;
  struct GSList * D.24430;
  <unnamed-unsigned:24> D.24431;
  int D.24432;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.24417 = ctx->image;
      table = &D.24417->tables[27];
      i = 0;
      goto <D.18866>;
      <D.18865>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.24418 = i + 1;
      D.24419 = D.24418 | 452984832;
      D.24420 = (unsigned int) D.24419;
      ctx->token = D.24420;
      D.24421 = data[0];
      D.24422 = is_valid_typespec_blob (ctx, D.24421);
      if (D.24422 == 0) goto <D.24423>; else goto <D.24424>;
      <D.24423>:
      D.24425 = ctx->report_error;
      if (D.24425 != 0) goto <D.24426>; else goto <D.24427>;
      <D.24426>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24421 = data[0];
        D.24428 = monoeg_g_strdup_printf ("Invalid TypeSpec row %d Signature field %08x", i, D.24421);
        vinfo->info.message = D.24428;
        vinfo->exception_type = 3;
        D.24429 = ctx->errors;
        D.24430 = monoeg_g_slist_prepend (D.24429, vinfo);
        ctx->errors = D.24430;
      }
      <D.24427>:
      ctx->valid = 0;
      return;
      <D.24424>:
      i = i + 1;
      <D.18866>:
      D.24431 = table->rows;
      D.24432 = (int) D.24431;
      if (D.24432 > i) goto <D.18865>; else goto <D.18867>;
      <D.18867>:
      ctx->token = 0;
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_typespec_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.24436;
  int D.24439;
  gchar * D.24442;
  struct GSList * D.24443;
  struct GSList * D.24444;
  gboolean D.24445;
  const char * ptr.191;
  unsigned int size.192;
  int D.24448;
  int D.24451;
  gchar * D.24456;
  struct GSList * D.24457;
  unsigned int type.193;
  int D.24461;
  gchar * D.24466;
  struct GSList * D.24467;
  gchar * D.24472;
  struct GSList * D.24473;
  const char * ptr.194;
  guint32 size;
  const char * ptr;
  const char * end;
  unsigned int type;

  try
    {
      size = 0;
      ptr = 0B;
      type = 0;
      D.24436 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.24436 == 0) goto <D.24437>; else goto <D.24438>;
      <D.24437>:
      D.24439 = ctx->report_error;
      if (D.24439 != 0) goto <D.24440>; else goto <D.24441>;
      <D.24440>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24442 = monoeg_strdup ("TypeSpec: Could not decode signature header");
        vinfo->info.message = D.24442;
        vinfo->exception_type = 3;
        D.24443 = ctx->errors;
        D.24444 = monoeg_g_slist_prepend (D.24443, vinfo);
        ctx->errors = D.24444;
      }
      <D.24441>:
      ctx->valid = 0;
      D.24445 = 0;
      return D.24445;
      <D.24438>:
      ptr.191 = ptr;
      size.192 = size;
      end = ptr.191 + size.192;
      D.24448 = parse_custom_mods (ctx, &ptr, end);
      if (D.24448 == 0) goto <D.24449>; else goto <D.24450>;
      <D.24449>:
      D.24445 = 0;
      return D.24445;
      <D.24450>:
      D.24451 = safe_read (&ptr, end, &type, 1);
      if (D.24451 == 0) goto <D.24452>; else goto <D.24453>;
      <D.24452>:
      D.24439 = ctx->report_error;
      if (D.24439 != 0) goto <D.24454>; else goto <D.24455>;
      <D.24454>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24456 = monoeg_strdup ("TypeSpec: Not enough room for type");
        vinfo->info.message = D.24456;
        vinfo->exception_type = 3;
        D.24443 = ctx->errors;
        D.24457 = monoeg_g_slist_prepend (D.24443, vinfo);
        ctx->errors = D.24457;
      }
      <D.24455>:
      ctx->valid = 0;
      D.24445 = 0;
      return D.24445;
      <D.24453>:
      type.193 = type;
      if (type.193 == 16) goto <D.24459>; else goto <D.24460>;
      <D.24459>:
      D.24461 = safe_read (&ptr, end, &type, 1);
      if (D.24461 == 0) goto <D.24462>; else goto <D.24463>;
      <D.24462>:
      D.24439 = ctx->report_error;
      if (D.24439 != 0) goto <D.24464>; else goto <D.24465>;
      <D.24464>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24466 = monoeg_strdup ("TypeSpec: Not enough room for byref type");
        vinfo->info.message = D.24466;
        vinfo->exception_type = 3;
        D.24443 = ctx->errors;
        D.24467 = monoeg_g_slist_prepend (D.24443, vinfo);
        ctx->errors = D.24467;
      }
      <D.24465>:
      ctx->valid = 0;
      D.24445 = 0;
      return D.24445;
      <D.24463>:
      type.193 = type;
      if (type.193 == 22) goto <D.24468>; else goto <D.24469>;
      <D.24468>:
      D.24439 = ctx->report_error;
      if (D.24439 != 0) goto <D.24470>; else goto <D.24471>;
      <D.24470>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24472 = monoeg_strdup ("TypeSpec: Invalid type typedref&");
        vinfo->info.message = D.24472;
        vinfo->exception_type = 3;
        D.24443 = ctx->errors;
        D.24473 = monoeg_g_slist_prepend (D.24443, vinfo);
        ctx->errors = D.24473;
      }
      <D.24471>:
      ctx->valid = 0;
      D.24445 = 0;
      return D.24445;
      <D.24469>:
      <D.24460>:
      type.193 = type;
      if (type.193 == 22) goto <D.24474>; else goto <D.24475>;
      <D.24474>:
      D.24445 = 1;
      return D.24445;
      <D.24475>:
      ptr.191 = ptr;
      ptr.194 = ptr.191 + 4294967295;
      ptr = ptr.194;
      D.24445 = parse_type (ctx, &ptr, end);
      return D.24445;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
      type = {CLOBBER};
    }
}


verify_method_spec_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24479;
  unsigned int D.24480;
  int D.24481;
  int D.24484;
  gchar * D.24487;
  struct GSList * D.24488;
  struct GSList * D.24489;
  <unnamed-unsigned:24> D.24490;
  int D.24491;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.24479 = ctx->image;
      table = &D.24479->tables[43];
      i = 0;
      goto <D.19024>;
      <D.19023>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.24480 = data[1];
      D.24481 = is_valid_methodspec_blob (ctx, D.24480);
      if (D.24481 == 0) goto <D.24482>; else goto <D.24483>;
      <D.24482>:
      D.24484 = ctx->report_error;
      if (D.24484 != 0) goto <D.24485>; else goto <D.24486>;
      <D.24485>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24480 = data[1];
        D.24487 = monoeg_g_strdup_printf ("MethodSpec table row %d has invalid Instantiation token %08x", i, D.24480);
        vinfo->info.message = D.24487;
        vinfo->exception_type = 3;
        D.24488 = ctx->errors;
        D.24489 = monoeg_g_slist_prepend (D.24488, vinfo);
        ctx->errors = D.24489;
      }
      <D.24486>:
      ctx->valid = 0;
      return;
      <D.24483>:
      i = i + 1;
      <D.19024>:
      D.24490 = table->rows;
      D.24491 = (int) D.24490;
      if (D.24491 > i) goto <D.19023>; else goto <D.19025>;
      <D.19025>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_methodspec_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.24495;
  int D.24498;
  gchar * D.24501;
  struct GSList * D.24502;
  struct GSList * D.24503;
  gboolean D.24504;
  const char * ptr.195;
  unsigned int size.196;
  int D.24507;
  gchar * D.24512;
  struct GSList * D.24513;
  unsigned int type.197;
  gchar * D.24519;
  struct GSList * D.24520;
  int D.24521;
  gchar * D.24526;
  struct GSList * D.24527;
  unsigned int count.198;
  gchar * D.24533;
  struct GSList * D.24534;
  int D.24535;
  int D.24538;
  unsigned int D.24543;
  gchar * D.24544;
  struct GSList * D.24545;
  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.24495 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.24495 == 0) goto <D.24496>; else goto <D.24497>;
      <D.24496>:
      D.24498 = ctx->report_error;
      if (D.24498 != 0) goto <D.24499>; else goto <D.24500>;
      <D.24499>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24501 = monoeg_strdup ("MethodSpec: Could not decode signature header");
        vinfo->info.message = D.24501;
        vinfo->exception_type = 3;
        D.24502 = ctx->errors;
        D.24503 = monoeg_g_slist_prepend (D.24502, vinfo);
        ctx->errors = D.24503;
      }
      <D.24500>:
      ctx->valid = 0;
      D.24504 = 0;
      return D.24504;
      <D.24497>:
      ptr.195 = ptr;
      size.196 = size;
      end = ptr.195 + size.196;
      D.24507 = safe_read (&ptr, end, &type, 1);
      if (D.24507 == 0) goto <D.24508>; else goto <D.24509>;
      <D.24508>:
      D.24498 = ctx->report_error;
      if (D.24498 != 0) goto <D.24510>; else goto <D.24511>;
      <D.24510>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24512 = monoeg_strdup ("MethodSpec: Not enough room for call convention");
        vinfo->info.message = D.24512;
        vinfo->exception_type = 3;
        D.24502 = ctx->errors;
        D.24513 = monoeg_g_slist_prepend (D.24502, vinfo);
        ctx->errors = D.24513;
      }
      <D.24511>:
      ctx->valid = 0;
      D.24504 = 0;
      return D.24504;
      <D.24509>:
      type.197 = type;
      if (type.197 != 10) goto <D.24515>; else goto <D.24516>;
      <D.24515>:
      D.24498 = ctx->report_error;
      if (D.24498 != 0) goto <D.24517>; else goto <D.24518>;
      <D.24517>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        type.197 = type;
        D.24519 = monoeg_g_strdup_printf ("MethodSpec: Invalid call convention 0x%x, expected 0x0A", type.197);
        vinfo->info.message = D.24519;
        vinfo->exception_type = 3;
        D.24502 = ctx->errors;
        D.24520 = monoeg_g_slist_prepend (D.24502, vinfo);
        ctx->errors = D.24520;
      }
      <D.24518>:
      ctx->valid = 0;
      D.24504 = 0;
      return D.24504;
      <D.24516>:
      D.24521 = safe_read_compressed_int (&ptr, end, &count);
      if (D.24521 == 0) goto <D.24522>; else goto <D.24523>;
      <D.24522>:
      D.24498 = ctx->report_error;
      if (D.24498 != 0) goto <D.24524>; else goto <D.24525>;
      <D.24524>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24526 = monoeg_strdup ("MethodSpec: Not enough room for parameter count");
        vinfo->info.message = D.24526;
        vinfo->exception_type = 3;
        D.24502 = ctx->errors;
        D.24527 = monoeg_g_slist_prepend (D.24502, vinfo);
        ctx->errors = D.24527;
      }
      <D.24525>:
      ctx->valid = 0;
      D.24504 = 0;
      return D.24504;
      <D.24523>:
      count.198 = count;
      if (count.198 == 0) goto <D.24529>; else goto <D.24530>;
      <D.24529>:
      D.24498 = ctx->report_error;
      if (D.24498 != 0) goto <D.24531>; else goto <D.24532>;
      <D.24531>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24533 = monoeg_strdup ("MethodSpec: Zero generic argument count");
        vinfo->info.message = D.24533;
        vinfo->exception_type = 3;
        D.24502 = ctx->errors;
        D.24534 = monoeg_g_slist_prepend (D.24502, vinfo);
        ctx->errors = D.24534;
      }
      <D.24532>:
      ctx->valid = 0;
      D.24504 = 0;
      return D.24504;
      <D.24530>:
      i = 0;
      goto <D.18269>;
      <D.18268>:
      D.24535 = parse_custom_mods (ctx, &ptr, end);
      if (D.24535 == 0) goto <D.24536>; else goto <D.24537>;
      <D.24536>:
      D.24504 = 0;
      return D.24504;
      <D.24537>:
      D.24538 = parse_type (ctx, &ptr, end);
      if (D.24538 == 0) goto <D.24539>; else goto <D.24540>;
      <D.24539>:
      D.24498 = ctx->report_error;
      if (D.24498 != 0) goto <D.24541>; else goto <D.24542>;
      <D.24541>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24543 = i + 1;
        D.24544 = monoeg_g_strdup_printf ("MethodSpec: Could not parse parameter %d", D.24543);
        vinfo->info.message = D.24544;
        vinfo->exception_type = 3;
        D.24502 = ctx->errors;
        D.24545 = monoeg_g_slist_prepend (D.24502, vinfo);
        ctx->errors = D.24545;
      }
      <D.24542>:
      ctx->valid = 0;
      D.24504 = 0;
      return D.24504;
      <D.24540>:
      i = i + 1;
      <D.18269>:
      count.198 = count;
      if (i < count.198) goto <D.18268>; else goto <D.18270>;
      <D.18270>:
      D.24504 = 1;
      return D.24504;
    }
  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.24548;
  <unnamed-unsigned:24> D.24549;
  unsigned int D.24550;
  struct MonoTableInfo * table;
  struct MonoError error;
  guint32 i;

  try
    {
      D.24548 = ctx->image;
      table = &D.24548->tables[1];
      i = 0;
      goto <D.18378>;
      <D.18377>:
      D.24548 = ctx->image;
      mono_verifier_verify_typeref_row (D.24548, i, &error);
      add_from_mono_error (ctx, &error);
      i = i + 1;
      <D.18378>:
      D.24549 = table->rows;
      D.24550 = (unsigned int) D.24549;
      if (D.24550 > i) goto <D.18377>; else goto <D.18379>;
      <D.18379>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


add_from_mono_error (struct VerifyContext * ctx, struct MonoError * error)
{
  int D.24551;
  int D.24554;
  const char * D.24557;
  gchar * D.24558;
  struct GSList * D.24559;
  struct GSList * D.24560;

  D.24551 = mono_error_ok (error);
  if (D.24551 != 0) goto <D.24552>; else goto <D.24553>;
  <D.24552>:
  return;
  <D.24553>:
  D.24554 = ctx->report_error;
  if (D.24554 != 0) goto <D.24555>; else goto <D.24556>;
  <D.24555>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.24557 = mono_error_get_message (error);
    D.24558 = monoeg_strdup (D.24557);
    vinfo->info.message = D.24558;
    vinfo->exception_type = 3;
    D.24559 = ctx->errors;
    D.24560 = monoeg_g_slist_prepend (D.24559, vinfo);
    ctx->errors = D.24560;
  }
  <D.24556>:
  ctx->valid = 0;
  return;
  mono_error_cleanup (error);
}


verify_typeref_table_global_constraints (struct VerifyContext * ctx)
{
  struct MonoImage * D.24562;
  unsigned int D.24563;
  unsigned int D.24564;
  const char * D.24565;
  unsigned int D.24566;
  const char * D.24567;
  void * D.24568;
  int D.24571;
  unsigned int D.24574;
  const char * D.24575;
  const char * D.24576;
  gchar * D.24577;
  struct GSList * D.24578;
  struct GSList * D.24579;
  <unnamed-unsigned:24> D.24580;
  int D.24581;
  int i;
  guint32 data[3];
  struct MonoTableInfo * table;
  struct GHashTable * unique_types;

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

        type = monoeg_malloc (12);
        mono_metadata_decode_row (table, i, &data, 3);
        D.24563 = data[0];
        type->resolution_scope = D.24563;
        D.24564 = data[1];
        D.24562 = ctx->image;
        D.24565 = mono_metadata_string_heap (D.24562, D.24564);
        type->name = D.24565;
        D.24566 = data[2];
        D.24562 = ctx->image;
        D.24567 = mono_metadata_string_heap (D.24562, D.24566);
        type->name_space = D.24567;
        D.24568 = monoeg_g_hash_table_lookup (unique_types, type);
        if (D.24568 != 0B) goto <D.24569>; else goto <D.24570>;
        <D.24569>:
        D.24571 = ctx->report_error;
        if (D.24571 != 0) goto <D.24572>; else goto <D.24573>;
        <D.24572>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.24574 = type->resolution_scope;
          D.24575 = type->name_space;
          D.24576 = type->name;
          D.24577 = monoeg_g_strdup_printf ("TypeRef table row %d has duplicate for tuple (%s,%s,%x)", i, D.24576, D.24575, D.24574);
          vinfo->info.message = D.24577;
          vinfo->exception_type = 3;
          D.24578 = ctx->errors;
          D.24579 = monoeg_g_slist_prepend (D.24578, vinfo);
          ctx->errors = D.24579;
        }
        <D.24573>:
        ctx->valid = 0;
        monoeg_g_hash_table_destroy (unique_types);
        monoeg_g_free (type);
        return;
        <D.24570>:
        monoeg_g_hash_table_insert_replace (unique_types, type, 1B, 0);
      }
      i = i + 1;
      <D.19101>:
      D.24580 = table->rows;
      D.24581 = (int) D.24580;
      if (D.24581 > i) goto <D.19100>; else goto <D.19102>;
      <D.19102>:
      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.24585;
  gboolean D.24588;
  _Bool D.24589;
  int D.24590;
  struct VerifyContext ctx;

  try
    {
      D.24585 = mono_verifier_is_enabled_for_image (image);
      if (D.24585 == 0) goto <D.24586>; else goto <D.24587>;
      <D.24586>:
      D.24588 = 1;
      return D.24588;
      <D.24587>:
      D.24589 = error_list != 0B;
      D.24590 = (int) D.24589;
      init_verify_context (&ctx, image, D.24590);
      ctx.stage = 2;
      is_valid_field_signature (&ctx, offset);
      D.24588 = cleanup_context (&ctx, error_list);
      return D.24588;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_method_header (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.24593;
  gboolean D.24596;
  _Bool D.24597;
  int D.24598;
  unsigned int locals_token.199;
  unsigned int D.24602;
  int D.24603;
  struct MonoTableInfo * D.24604;
  struct VerifyContext ctx;
  guint32 locals_token;

  try
    {
      D.24593 = mono_verifier_is_enabled_for_image (image);
      if (D.24593 == 0) goto <D.24594>; else goto <D.24595>;
      <D.24594>:
      D.24596 = 1;
      return D.24596;
      <D.24595>:
      D.24597 = error_list != 0B;
      D.24598 = (int) D.24597;
      init_verify_context (&ctx, image, D.24598);
      ctx.stage = 2;
      is_valid_method_header (&ctx, offset, &locals_token);
      locals_token.199 = locals_token;
      if (locals_token.199 != 0) goto <D.24600>; else goto <D.24601>;
      <D.24600>:
      {
        guint32 sig_offset;

        locals_token.199 = locals_token;
        D.24602 = locals_token.199 + 4294967295;
        D.24603 = (int) D.24602;
        D.24604 = &image->tables[17];
        sig_offset = mono_metadata_decode_row_col (D.24604, D.24603, 0);
        is_valid_standalonesig_blob (&ctx, sig_offset);
      }
      <D.24601>:
      D.24596 = cleanup_context (&ctx, error_list);
      return D.24596;
    }
  finally
    {
      ctx = {CLOBBER};
      locals_token = {CLOBBER};
    }
}


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

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


cleanup_context_checked (struct VerifyContext * ctx, struct MonoError * error)
{
  struct SectionHeader * D.24613;
  struct GSList * D.24614;
  char * D.24617;
  struct MonoImage * D.24618;
  gboolean D.24619;

  D.24613 = ctx->sections;
  monoeg_g_free (D.24613);
  D.24614 = ctx->errors;
  if (D.24614 != 0B) goto <D.24615>; else goto <D.24616>;
  <D.24615>:
  {
    struct MonoVerifyInfo * info;

    D.24614 = ctx->errors;
    info = D.24614->data;
    D.24617 = info->message;
    D.24618 = ctx->image;
    mono_error_set_bad_image (error, D.24618, "%s", D.24617);
    D.24614 = ctx->errors;
    mono_free_verify_list (D.24614);
  }
  <D.24616>:
  D.24619 = ctx->valid;
  return D.24619;
}


mono_verifier_verify_memberref_method_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.24621;
  gboolean D.24624;
  _Bool D.24625;
  int D.24626;
  struct VerifyContext ctx;

  try
    {
      D.24621 = mono_verifier_is_enabled_for_image (image);
      if (D.24621 == 0) goto <D.24622>; else goto <D.24623>;
      <D.24622>:
      D.24624 = 1;
      return D.24624;
      <D.24623>:
      D.24625 = error_list != 0B;
      D.24626 = (int) D.24625;
      init_verify_context (&ctx, image, D.24626);
      ctx.stage = 2;
      is_valid_memberref_method_signature (&ctx, offset);
      D.24624 = cleanup_context (&ctx, error_list);
      return D.24624;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


is_valid_memberref_method_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.24629;
  int D.24632;
  gchar * D.24635;
  struct GSList * D.24636;
  struct GSList * D.24637;
  gboolean D.24638;
  const char * ptr.200;
  unsigned int size.201;
  guint32 size;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      ptr = 0B;
      D.24629 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.24629 == 0) goto <D.24630>; else goto <D.24631>;
      <D.24630>:
      D.24632 = ctx->report_error;
      if (D.24632 != 0) goto <D.24633>; else goto <D.24634>;
      <D.24633>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24635 = monoeg_strdup ("MemberRefSig: Could not decode signature header");
        vinfo->info.message = D.24635;
        vinfo->exception_type = 3;
        D.24636 = ctx->errors;
        D.24637 = monoeg_g_slist_prepend (D.24636, vinfo);
        ctx->errors = D.24637;
      }
      <D.24634>:
      ctx->valid = 0;
      D.24638 = 0;
      return D.24638;
      <D.24631>:
      ptr.200 = ptr;
      size.201 = size;
      end = ptr.200 + size.201;
      D.24638 = parse_method_signature (ctx, &ptr, end, 1, 0);
      return D.24638;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


mono_verifier_verify_memberref_field_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.24643;
  gboolean D.24646;
  _Bool D.24647;
  int D.24648;
  struct VerifyContext ctx;

  try
    {
      D.24643 = mono_verifier_is_enabled_for_image (image);
      if (D.24643 == 0) goto <D.24644>; else goto <D.24645>;
      <D.24644>:
      D.24646 = 1;
      return D.24646;
      <D.24645>:
      D.24647 = error_list != 0B;
      D.24648 = (int) D.24647;
      init_verify_context (&ctx, image, D.24648);
      ctx.stage = 2;
      is_valid_field_signature (&ctx, offset);
      D.24646 = cleanup_context (&ctx, error_list);
      return D.24646;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_standalone_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.24651;
  gboolean D.24654;
  _Bool D.24655;
  int D.24656;
  struct VerifyContext ctx;

  try
    {
      D.24651 = mono_verifier_is_enabled_for_image (image);
      if (D.24651 == 0) goto <D.24652>; else goto <D.24653>;
      <D.24652>:
      D.24654 = 1;
      return D.24654;
      <D.24653>:
      D.24655 = error_list != 0B;
      D.24656 = (int) D.24655;
      init_verify_context (&ctx, image, D.24656);
      ctx.stage = 2;
      is_valid_standalonesig_blob (&ctx, offset);
      D.24654 = cleanup_context (&ctx, error_list);
      return D.24654;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_typespec_signature (struct MonoImage * image, guint32 offset, guint32 token, struct GSList * * error_list)
{
  int D.24659;
  gboolean D.24662;
  _Bool D.24663;
  int D.24664;
  struct VerifyContext ctx;

  try
    {
      D.24659 = mono_verifier_is_enabled_for_image (image);
      if (D.24659 == 0) goto <D.24660>; else goto <D.24661>;
      <D.24660>:
      D.24662 = 1;
      return D.24662;
      <D.24661>:
      D.24663 = error_list != 0B;
      D.24664 = (int) D.24663;
      init_verify_context (&ctx, image, D.24664);
      ctx.stage = 2;
      ctx.token = token;
      is_valid_typespec_blob (&ctx, offset);
      D.24662 = cleanup_context (&ctx, error_list);
      return D.24662;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_methodspec_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.24667;
  gboolean D.24670;
  _Bool D.24671;
  int D.24672;
  struct VerifyContext ctx;

  try
    {
      D.24667 = mono_verifier_is_enabled_for_image (image);
      if (D.24667 == 0) goto <D.24668>; else goto <D.24669>;
      <D.24668>:
      D.24670 = 1;
      return D.24670;
      <D.24669>:
      D.24671 = error_list != 0B;
      D.24672 = (int) D.24671;
      init_verify_context (&ctx, image, D.24672);
      ctx.stage = 2;
      is_valid_methodspec_blob (&ctx, offset);
      D.24670 = cleanup_context (&ctx, error_list);
      return D.24670;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_string_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.24675;
  gboolean D.24678;
  _Bool D.24679;
  int D.24680;
  struct VerifyContext ctx;

  try
    {
      D.24675 = mono_verifier_is_enabled_for_image (image);
      if (D.24675 == 0) goto <D.24676>; else goto <D.24677>;
      <D.24676>:
      D.24678 = 1;
      return D.24678;
      <D.24677>:
      D.24679 = error_list != 0B;
      D.24680 = (int) D.24679;
      init_verify_context (&ctx, image, D.24680);
      ctx.stage = 2;
      verify_user_string (&ctx, offset);
      D.24678 = cleanup_context (&ctx, error_list);
      return D.24678;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


verify_user_string (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.24683;
  struct MonoStreamHeader * D.24684;
  unsigned int D.24685;
  int D.24688;
  gchar * D.24691;
  struct GSList * D.24692;
  struct GSList * D.24693;
  unsigned int D.24694;
  unsigned int D.24695;
  const char * D.24696;
  sizetype D.24697;
  const char * D.24698;
  int D.24699;
  gchar * D.24704;
  struct GSList * D.24705;
  unsigned int bytes.202;
  unsigned int D.24707;
  unsigned int entry_size.203;
  gchar * D.24713;
  struct GSList * D.24714;
  unsigned int entry_size.204;
  unsigned int D.24718;
  unsigned int D.24720;
  gchar * D.24723;
  struct GSList * D.24724;
  struct OffsetAndSize heap_us;
  guint32 entry_size;
  guint32 bytes;

  try
    {
      D.24683 = ctx->image;
      D.24684 = &D.24683->heap_us;
      heap_us = get_metadata_stream (ctx, D.24684); [return slot optimization]
      D.24685 = heap_us.size;
      if (D.24685 < offset) goto <D.24686>; else goto <D.24687>;
      <D.24686>:
      D.24688 = ctx->report_error;
      if (D.24688 != 0) goto <D.24689>; else goto <D.24690>;
      <D.24689>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24691 = monoeg_strdup ("User string offset beyond heap_us size");
        vinfo->info.message = D.24691;
        vinfo->exception_type = 3;
        D.24692 = ctx->errors;
        D.24693 = monoeg_g_slist_prepend (D.24692, vinfo);
        ctx->errors = D.24693;
      }
      <D.24690>:
      ctx->valid = 0;
      return;
      <D.24687>:
      D.24685 = heap_us.size;
      D.24694 = heap_us.offset;
      D.24695 = D.24685 - D.24694;
      D.24696 = ctx->data;
      D.24694 = heap_us.offset;
      D.24697 = D.24694 + offset;
      D.24698 = D.24696 + D.24697;
      D.24699 = decode_value (D.24698, D.24695, &entry_size, &bytes);
      if (D.24699 == 0) goto <D.24700>; else goto <D.24701>;
      <D.24700>:
      D.24688 = ctx->report_error;
      if (D.24688 != 0) goto <D.24702>; else goto <D.24703>;
      <D.24702>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24704 = monoeg_strdup ("Could not decode user string blob size");
        vinfo->info.message = D.24704;
        vinfo->exception_type = 3;
        D.24692 = ctx->errors;
        D.24705 = monoeg_g_slist_prepend (D.24692, vinfo);
        ctx->errors = D.24705;
      }
      <D.24703>:
      ctx->valid = 0;
      return;
      <D.24701>:
      bytes.202 = bytes;
      D.24707 = ~bytes.202;
      entry_size.203 = entry_size;
      if (D.24707 < entry_size.203) goto <D.24709>; else goto <D.24710>;
      <D.24709>:
      D.24688 = ctx->report_error;
      if (D.24688 != 0) goto <D.24711>; else goto <D.24712>;
      <D.24711>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24713 = monoeg_strdup ("User string size overflow");
        vinfo->info.message = D.24713;
        vinfo->exception_type = 3;
        D.24692 = ctx->errors;
        D.24714 = monoeg_g_slist_prepend (D.24692, vinfo);
        ctx->errors = D.24714;
      }
      <D.24712>:
      ctx->valid = 0;
      return;
      <D.24710>:
      entry_size.203 = entry_size;
      bytes.202 = bytes;
      entry_size.204 = entry_size.203 + bytes.202;
      entry_size = entry_size.204;
      entry_size.203 = entry_size;
      D.24718 = offset + entry_size.203;
      D.24685 = heap_us.size;
      if (D.24718 > D.24685) goto <D.24716>; else goto <D.24719>;
      <D.24719>:
      entry_size.203 = entry_size;
      D.24720 = ~entry_size.203;
      if (D.24720 < offset) goto <D.24716>; else goto <D.24717>;
      <D.24716>:
      D.24688 = ctx->report_error;
      if (D.24688 != 0) goto <D.24721>; else goto <D.24722>;
      <D.24721>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24723 = monoeg_strdup ("User string oveflow heap_us");
        vinfo->info.message = D.24723;
        vinfo->exception_type = 3;
        D.24692 = ctx->errors;
        D.24724 = monoeg_g_slist_prepend (D.24692, vinfo);
        ctx->errors = D.24724;
      }
      <D.24722>:
      ctx->valid = 0;
      return;
      <D.24717>:
    }
  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.24728;
  gboolean D.24731;
  _Bool D.24732;
  int D.24733;
  struct VerifyContext ctx;

  try
    {
      D.24728 = mono_verifier_is_enabled_for_image (image);
      if (D.24728 == 0) goto <D.24729>; else goto <D.24730>;
      <D.24729>:
      D.24731 = 1;
      return D.24731;
      <D.24730>:
      D.24732 = error_list != 0B;
      D.24733 = (int) D.24732;
      init_verify_context (&ctx, image, D.24733);
      ctx.stage = 2;
      is_valid_cattr_blob (&ctx, offset);
      D.24731 = cleanup_context (&ctx, error_list);
      return D.24731;
    }
  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.24736;
  gboolean D.24739;
  _Bool D.24740;
  int D.24741;
  struct VerifyContext ctx;

  try
    {
      D.24736 = mono_verifier_is_enabled_for_image (image);
      if (D.24736 == 0) goto <D.24737>; else goto <D.24738>;
      <D.24737>:
      D.24739 = 1;
      return D.24739;
      <D.24738>:
      D.24740 = error_list != 0B;
      D.24741 = (int) D.24740;
      init_verify_context (&ctx, image, D.24741);
      ctx.stage = 2;
      is_valid_cattr_content (&ctx, ctor, data, size);
      D.24739 = cleanup_context (&ctx, error_list);
      return D.24739;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_is_sig_compatible (struct MonoImage * image, struct MonoMethod * method, struct MonoMethodSignature * signature)
{
  int D.24744;
  gboolean D.24747;
  unsigned char D.24748;
  unsigned char D.24749;
  unsigned char D.24752;
  unsigned char D.24753;
  unsigned char D.24754;
  unsigned char D.24757;
  signed char D.24760;
  unsigned char D.24765;
  unsigned char D.24766;
  unsigned char D.24767;
  unsigned char D.24768;
  short int D.24771;
  short int D.24772;
  int D.24776;
  struct MonoMethodSignature * original_sig;

  D.24744 = mono_verifier_is_enabled_for_image (image);
  if (D.24744 == 0) goto <D.24745>; else goto <D.24746>;
  <D.24745>:
  D.24747 = 1;
  return D.24747;
  <D.24746>:
  original_sig = mono_method_signature (method);
  D.24748 = BIT_FIELD_REF <*original_sig, 8, 80>;
  D.24749 = D.24748 & 63;
  if (D.24749 == 5) goto <D.24750>; else goto <D.24751>;
  <D.24750>:
  D.24748 = BIT_FIELD_REF <*original_sig, 8, 80>;
  D.24752 = BIT_FIELD_REF <*signature, 8, 80>;
  D.24753 = D.24748 ^ D.24752;
  D.24754 = D.24753 & 64;
  if (D.24754 != 0) goto <D.24755>; else goto <D.24756>;
  <D.24755>:
  D.24747 = 0;
  return D.24747;
  <D.24756>:
  D.24748 = BIT_FIELD_REF <*original_sig, 8, 80>;
  D.24752 = BIT_FIELD_REF <*signature, 8, 80>;
  D.24753 = D.24748 ^ D.24752;
  D.24757 = D.24753 & 63;
  if (D.24757 != 0) goto <D.24758>; else goto <D.24759>;
  <D.24758>:
  D.24747 = 0;
  return D.24747;
  <D.24759>:
  D.24748 = BIT_FIELD_REF <*original_sig, 8, 80>;
  D.24752 = BIT_FIELD_REF <*signature, 8, 80>;
  D.24753 = D.24748 ^ D.24752;
  D.24760 = (signed char) D.24753;
  if (D.24760 < 0) goto <D.24761>; else goto <D.24762>;
  <D.24761>:
  D.24747 = 0;
  return D.24747;
  <D.24762>:
  D.24748 = BIT_FIELD_REF <*original_sig, 8, 80>;
  D.24752 = BIT_FIELD_REF <*signature, 8, 80>;
  D.24753 = D.24748 ^ D.24752;
  D.24757 = D.24753 & 63;
  if (D.24757 != 0) goto <D.24763>; else goto <D.24764>;
  <D.24763>:
  D.24747 = 0;
  return D.24747;
  <D.24764>:
  D.24765 = BIT_FIELD_REF <*original_sig, 8, 88>;
  D.24766 = BIT_FIELD_REF <*signature, 8, 88>;
  D.24767 = D.24765 ^ D.24766;
  D.24768 = D.24767 & 1;
  if (D.24768 != 0) goto <D.24769>; else goto <D.24770>;
  <D.24769>:
  D.24747 = 0;
  return D.24747;
  <D.24770>:
  D.24771 = original_sig->sentinelpos;
  D.24772 = signature->sentinelpos;
  if (D.24771 != D.24772) goto <D.24773>; else goto <D.24774>;
  <D.24773>:
  D.24747 = 0;
  return D.24747;
  <D.24774>:
  goto <D.24775>;
  <D.24751>:
  D.24776 = mono_metadata_signature_equal (signature, original_sig);
  if (D.24776 == 0) goto <D.24777>; else goto <D.24778>;
  <D.24777>:
  D.24747 = 0;
  return D.24747;
  <D.24778>:
  <D.24775>:
  D.24747 = 1;
  return D.24747;
}


mono_verifier_verify_typeref_row (struct MonoImage * image, guint32 row, struct MonoError * error)
{
  int D.24780;
  gboolean D.24783;
  <unnamed-unsigned:24> D.24784;
  unsigned int D.24785;
  int D.24788;
  int row.205;
  unsigned int D.24790;
  int D.24791;
  unsigned int D.24794;
  unsigned int D.24799;
  int D.24801;
  unsigned int D.24802;
  int D.24805;
  struct MonoTableInfo * table;
  guint32 data[3];

  try
    {
      table = &image->tables[1];
      mono_error_init (error);
      D.24780 = mono_verifier_is_enabled_for_image (image);
      if (D.24780 == 0) goto <D.24781>; else goto <D.24782>;
      <D.24781>:
      D.24783 = 1;
      return D.24783;
      <D.24782>:
      D.24784 = table->rows;
      D.24785 = (unsigned int) D.24784;
      if (D.24785 <= row) goto <D.24786>; else goto <D.24787>;
      <D.24786>:
      D.24784 = table->rows;
      D.24788 = (int) D.24784;
      mono_error_set_bad_image (error, image, "Invalid typeref row %d - table has %d rows", row, D.24788);
      D.24783 = 0;
      return D.24783;
      <D.24787>:
      row.205 = (int) row;
      mono_metadata_decode_row (table, row.205, &data, 3);
      D.24790 = data[0];
      D.24791 = is_valid_coded_index_with_image (image, 72, D.24790);
      if (D.24791 == 0) goto <D.24792>; else goto <D.24793>;
      <D.24792>:
      D.24790 = data[0];
      mono_error_set_bad_image (error, image, "Invalid typeref row %d coded index 0x%08x", row, D.24790);
      D.24783 = 0;
      return D.24783;
      <D.24793>:
      D.24790 = data[0];
      D.24794 = get_coded_index_token (72, D.24790);
      if (D.24794 == 0) goto <D.24795>; else goto <D.24796>;
      <D.24795>:
      mono_error_set_bad_image (error, image, "The metadata verifier doesn\'t support null ResolutionScope tokens for typeref row %d", row);
      D.24783 = 0;
      return D.24783;
      <D.24796>:
      D.24799 = data[1];
      if (D.24799 == 0) goto <D.24797>; else goto <D.24800>;
      <D.24800>:
      D.24799 = data[1];
      D.24801 = is_valid_string_full_with_image (image, D.24799, 0);
      if (D.24801 == 0) goto <D.24797>; else goto <D.24798>;
      <D.24797>:
      D.24799 = data[1];
      mono_error_set_bad_image (error, image, "Invalid typeref row %d name token 0x%08x", row, D.24799);
      D.24783 = 0;
      return D.24783;
      <D.24798>:
      D.24802 = data[2];
      if (D.24802 != 0) goto <D.24803>; else goto <D.24804>;
      <D.24803>:
      D.24802 = data[2];
      D.24805 = is_valid_string_full_with_image (image, D.24802, 0);
      if (D.24805 == 0) goto <D.24806>; else goto <D.24807>;
      <D.24806>:
      D.24802 = data[2];
      mono_error_set_bad_image (error, image, "Invalid typeref row %d namespace token 0x%08x", row, D.24802);
      D.24783 = 0;
      return D.24783;
      <D.24807>:
      <D.24804>:
      D.24783 = 1;
      return D.24783;
    }
  finally
    {
      data = {CLOBBER};
    }
}


mono_verifier_verify_methodimpl_row (struct MonoImage * image, guint32 row, struct MonoError * error)
{
  int D.24810;
  gboolean D.24813;
  <unnamed-unsigned:24> D.24814;
  unsigned int D.24815;
  int D.24818;
  int row.206;
  unsigned int D.24820;
  struct MonoLoaderError * D.24824;
  unsigned int D.24825;
  struct MonoLoaderError * D.24829;
  int D.24834;
  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.24810 = mono_verifier_is_enabled_for_image (image);
      if (D.24810 == 0) goto <D.24811>; else goto <D.24812>;
      <D.24811>:
      D.24813 = 1;
      return D.24813;
      <D.24812>:
      D.24814 = table->rows;
      D.24815 = (unsigned int) D.24814;
      if (D.24815 <= row) goto <D.24816>; else goto <D.24817>;
      <D.24816>:
      D.24814 = table->rows;
      D.24818 = (int) D.24814;
      mono_error_set_bad_image (error, image, "Invalid methodimpl row %d - table has %d rows", row, D.24818);
      D.24813 = 0;
      return D.24813;
      <D.24817>:
      row.206 = (int) row;
      mono_metadata_decode_row (table, row.206, &data, 3);
      D.24820 = data[1];
      body = method_from_method_def_or_ref (image, D.24820, 0B);
      if (body == 0B) goto <D.24821>; else goto <D.24823>;
      <D.24823>:
      D.24824 = mono_loader_get_last_error ();
      if (D.24824 != 0B) goto <D.24821>; else goto <D.24822>;
      <D.24821>:
      mono_loader_clear_error ();
      mono_error_set_bad_image (error, image, "Invalid methodimpl body for row %x", row);
      D.24813 = 0;
      return D.24813;
      <D.24822>:
      D.24825 = data[2];
      declaration = method_from_method_def_or_ref (image, D.24825, 0B);
      if (declaration == 0B) goto <D.24826>; else goto <D.24828>;
      <D.24828>:
      D.24829 = mono_loader_get_last_error ();
      if (D.24829 != 0B) goto <D.24826>; else goto <D.24827>;
      <D.24826>:
      mono_loader_clear_error ();
      mono_error_set_bad_image (error, image, "Invalid methodimpl declaration for row %x", row);
      D.24813 = 0;
      return D.24813;
      <D.24827>:
      body_sig = mono_method_signature_checked (body, error);
      if (body_sig == 0B) goto <D.24830>; else goto <D.24831>;
      <D.24830>:
      D.24813 = 0;
      return D.24813;
      <D.24831>:
      decl_sig = mono_method_signature_checked (declaration, error);
      if (decl_sig == 0B) goto <D.24832>; else goto <D.24833>;
      <D.24832>:
      D.24813 = 0;
      return D.24813;
      <D.24833>:
      D.24834 = mono_verifier_is_signature_compatible (decl_sig, body_sig);
      if (D.24834 == 0) goto <D.24835>; else goto <D.24836>;
      <D.24835>:
      mono_error_set_bad_image (error, image, "Invalid methodimpl body signature not compatible with declaration row %x", row);
      D.24813 = 0;
      return D.24813;
      <D.24836>:
      D.24813 = 1;
      return D.24813;
    }
  finally
    {
      data = {CLOBBER};
    }
}