mono_verifier_verify_pe_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.19239;
  gboolean D.19242;
  _Bool D.19243;
  int D.19244;
  int D.19245;
  struct VerifyContext ctx;
  void cleanup = <<< error >>>;

  try
    {
      D.19239 = mono_verifier_is_enabled_for_image (image);
      if (D.19239 == 0) goto <D.19240>; else goto <D.19241>;
      <D.19240>:
      D.19242 = 1;
      return D.19242;
      <D.19241>:
      D.19243 = error_list != 0B;
      D.19244 = (int) D.19243;
      init_verify_context (&ctx, image, D.19244);
      ctx.stage = 0;
      verify_msdos_header (&ctx);
      D.19245 = ctx.valid;
      if (D.19245 == 0) goto cleanup; else goto <D.19246>;
      <D.19246>:
      verify_pe_header (&ctx);
      D.19245 = ctx.valid;
      if (D.19245 == 0) goto cleanup; else goto <D.19247>;
      <D.19247>:
      verify_pe_optional_header (&ctx);
      D.19245 = ctx.valid;
      if (D.19245 == 0) goto cleanup; else goto <D.19248>;
      <D.19248>:
      load_section_table (&ctx);
      D.19245 = ctx.valid;
      if (D.19245 == 0) goto cleanup; else goto <D.19249>;
      <D.19249>:
      load_data_directories (&ctx);
      D.19245 = ctx.valid;
      if (D.19245 == 0) goto cleanup; else goto <D.19250>;
      <D.19250>:
      verify_import_table (&ctx);
      D.19245 = ctx.valid;
      if (D.19245 == 0) goto cleanup; else goto <D.19251>;
      <D.19251>:
      verify_resources_table (&ctx);
      cleanup:
      D.19242 = cleanup_context (&ctx, error_list);
      return D.19242;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


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

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.19258;
  int D.19263;
  void * D.19265;
  unsigned int D.19266;

  D.19258 = __builtin_constant_p (__len);
  if (D.19258 != 0) goto <D.19259>; else goto <D.19260>;
  <D.19259>:
  if (__len == 0) goto <D.19261>; else goto <D.19262>;
  <D.19261>:
  D.19263 = __builtin_constant_p (__ch);
  if (D.19263 == 0) goto <D.19256>; else goto <D.19264>;
  <D.19264>:
  if (__ch != 0) goto <D.19256>; else goto <D.19257>;
  <D.19256>:
  __warn_memset_zero_len ();
  D.19265 = __dest;
  return D.19265;
  <D.19257>:
  <D.19262>:
  <D.19260>:
  D.19266 = __builtin_object_size (__dest, 0);
  D.19265 = __builtin___memset_chk (__dest, __ch, __len, D.19266);
  return D.19265;
}


verify_msdos_header (struct VerifyContext * ctx)
{
  unsigned int D.19268;
  int D.19271;
  gchar * D.19274;
  struct GSList * D.19275;
  struct GSList * D.19276;
  const char * D.19279;
  char D.19280;
  const char * D.19282;
  char D.19283;
  gchar * D.19286;
  struct GSList * D.19287;
  unsigned int D.19288;
  gchar * D.19293;
  struct GSList * D.19294;
  guint32 lfanew;

  D.19268 = ctx->size;
  if (D.19268 <= 127) goto <D.19269>; else goto <D.19270>;
  <D.19269>:
  D.19271 = ctx->report_error;
  if (D.19271 != 0) goto <D.19272>; else goto <D.19273>;
  <D.19272>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19274 = monoeg_strdup ("Not enough space for the MS-DOS header");
    vinfo->info.message = D.19274;
    vinfo->exception_type = 3;
    D.19275 = ctx->errors;
    D.19276 = monoeg_g_slist_prepend (D.19275, vinfo);
    ctx->errors = D.19276;
  }
  <D.19273>:
  ctx->valid = 0;
  return;
  <D.19270>:
  D.19279 = ctx->data;
  D.19280 = *D.19279;
  if (D.19280 != 77) goto <D.19277>; else goto <D.19281>;
  <D.19281>:
  D.19279 = ctx->data;
  D.19282 = D.19279 + 1;
  D.19283 = *D.19282;
  if (D.19283 != 90) goto <D.19277>; else goto <D.19278>;
  <D.19277>:
  D.19271 = ctx->report_error;
  if (D.19271 != 0) goto <D.19284>; else goto <D.19285>;
  <D.19284>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19286 = monoeg_strdup ("Invalid MS-DOS watermark");
    vinfo->info.message = D.19286;
    vinfo->exception_type = 3;
    D.19275 = ctx->errors;
    D.19287 = monoeg_g_slist_prepend (D.19275, vinfo);
    ctx->errors = D.19287;
  }
  <D.19285>:
  ctx->valid = 0;
  return;
  <D.19278>:
  lfanew = pe_signature_offset (ctx);
  D.19268 = ctx->size;
  D.19288 = D.19268 + 4294967292;
  if (D.19288 < lfanew) goto <D.19289>; else goto <D.19290>;
  <D.19289>:
  D.19271 = ctx->report_error;
  if (D.19271 != 0) goto <D.19291>; else goto <D.19292>;
  <D.19291>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19293 = monoeg_strdup ("MS-DOS lfanew offset points to outside of the file");
    vinfo->info.message = D.19293;
    vinfo->exception_type = 3;
    D.19275 = ctx->errors;
    D.19294 = monoeg_g_slist_prepend (D.19275, vinfo);
    ctx->errors = D.19294;
  }
  <D.19292>:
  ctx->valid = 0;
  return;
  <D.19290>:
}


pe_signature_offset (struct VerifyContext * ctx)
{
  guint32 D.19296;
  const char * D.19297;
  const unsigned char * D.19298;

  D.19297 = ctx->data;
  D.19298 = D.19297 + 60;
  D.19296 = mono_read32 (D.19298);
  return D.19296;
}


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

  if (str != 0B) goto <D.19300>; else goto <D.19301>;
  <D.19300>:
  D.19302 = __strdup (str);
  return D.19302;
  <D.19301>:
  D.19302 = 0B;
  return D.19302;
}


verify_pe_header (struct VerifyContext * ctx)
{
  const char * D.19304;
  char D.19307;
  const char * D.19309;
  char D.19310;
  const char * D.19312;
  char D.19313;
  const char * D.19315;
  char D.19316;
  int D.19317;
  gchar * D.19320;
  struct GSList * D.19321;
  struct GSList * D.19322;
  unsigned int D.19323;
  unsigned int D.19324;
  gchar * D.19329;
  struct GSList * D.19330;
  short unsigned int D.19331;
  gchar * D.19336;
  struct GSList * D.19337;
  guint32 offset;
  const char * pe_header;

  offset = pe_signature_offset (ctx);
  D.19304 = ctx->data;
  pe_header = D.19304 + offset;
  D.19307 = *pe_header;
  if (D.19307 != 80) goto <D.19305>; else goto <D.19308>;
  <D.19308>:
  D.19309 = pe_header + 1;
  D.19310 = *D.19309;
  if (D.19310 != 69) goto <D.19305>; else goto <D.19311>;
  <D.19311>:
  D.19312 = pe_header + 2;
  D.19313 = *D.19312;
  if (D.19313 != 0) goto <D.19305>; else goto <D.19314>;
  <D.19314>:
  D.19315 = pe_header + 3;
  D.19316 = *D.19315;
  if (D.19316 != 0) goto <D.19305>; else goto <D.19306>;
  <D.19305>:
  D.19317 = ctx->report_error;
  if (D.19317 != 0) goto <D.19318>; else goto <D.19319>;
  <D.19318>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19320 = monoeg_strdup ("Invalid PE header watermark");
    vinfo->info.message = D.19320;
    vinfo->exception_type = 3;
    D.19321 = ctx->errors;
    D.19322 = monoeg_g_slist_prepend (D.19321, vinfo);
    ctx->errors = D.19322;
  }
  <D.19319>:
  ctx->valid = 0;
  return;
  <D.19306>:
  pe_header = pe_header + 4;
  offset = offset + 4;
  D.19323 = ctx->size;
  D.19324 = D.19323 + 4294967276;
  if (D.19324 < offset) goto <D.19325>; else goto <D.19326>;
  <D.19325>:
  D.19317 = ctx->report_error;
  if (D.19317 != 0) goto <D.19327>; else goto <D.19328>;
  <D.19327>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19329 = monoeg_strdup ("File with truncated pe header");
    vinfo->info.message = D.19329;
    vinfo->exception_type = 3;
    D.19321 = ctx->errors;
    D.19330 = monoeg_g_slist_prepend (D.19321, vinfo);
    ctx->errors = D.19330;
  }
  <D.19328>:
  ctx->valid = 0;
  return;
  <D.19326>:
  D.19331 = mono_read16 (pe_header);
  if (D.19331 != 332) goto <D.19332>; else goto <D.19333>;
  <D.19332>:
  D.19317 = ctx->report_error;
  if (D.19317 != 0) goto <D.19334>; else goto <D.19335>;
  <D.19334>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19336 = monoeg_strdup ("Invalid PE header Machine value");
    vinfo->info.message = D.19336;
    vinfo->exception_type = 3;
    D.19321 = ctx->errors;
    D.19337 = monoeg_g_slist_prepend (D.19321, vinfo);
    ctx->errors = D.19337;
  }
  <D.19335>:
  ctx->valid = 0;
  return;
  <D.19333>:
}


verify_pe_optional_header (struct VerifyContext * ctx)
{
  const char * D.19339;
  const unsigned char * D.19340;
  short unsigned int D.19341;
  int D.19344;
  gchar * D.19347;
  struct GSList * D.19348;
  struct GSList * D.19349;
  unsigned int D.19352;
  unsigned int D.19353;
  gchar * D.19357;
  struct GSList * D.19358;
  short unsigned int D.19359;
  gchar * D.19366;
  struct GSList * D.19367;
  const unsigned char * D.19368;
  unsigned int D.19369;
  unsigned int D.19374;
  gchar * D.19375;
  struct GSList * D.19376;
  const unsigned char * D.19377;
  gchar * D.19384;
  struct GSList * D.19385;
  const unsigned char * D.19386;
  unsigned int D.19387;
  unsigned int D.19392;
  gchar * D.19393;
  struct GSList * D.19394;
  short unsigned int D.19396;
  gchar * D.19401;
  struct GSList * D.19402;
  short unsigned int D.19405;
  int D.19406;
  gchar * D.19407;
  struct GSList * D.19408;
  guint32 offset;
  guint32 header_size;
  guint32 file_alignment;
  const char * pe_header;
  const char * pe_optional_header;

  offset = pe_header_offset (ctx);
  D.19339 = ctx->data;
  pe_header = D.19339 + offset;
  pe_optional_header = pe_header + 20;
  D.19340 = pe_header + 16;
  D.19341 = mono_read16 (D.19340);
  header_size = (guint32) D.19341;
  offset = offset + 20;
  if (header_size <= 1) goto <D.19342>; else goto <D.19343>;
  <D.19342>:
  D.19344 = ctx->report_error;
  if (D.19344 != 0) goto <D.19345>; else goto <D.19346>;
  <D.19345>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19347 = monoeg_strdup ("Invalid PE optional header size");
    vinfo->info.message = D.19347;
    vinfo->exception_type = 3;
    D.19348 = ctx->errors;
    D.19349 = monoeg_g_slist_prepend (D.19348, vinfo);
    ctx->errors = D.19349;
  }
  <D.19346>:
  ctx->valid = 0;
  return;
  <D.19343>:
  D.19352 = ctx->size;
  D.19353 = D.19352 - header_size;
  if (D.19353 < offset) goto <D.19350>; else goto <D.19354>;
  <D.19354>:
  D.19352 = ctx->size;
  if (D.19352 < header_size) goto <D.19350>; else goto <D.19351>;
  <D.19350>:
  D.19344 = ctx->report_error;
  if (D.19344 != 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 ("Invalid PE optional header size");
    vinfo->info.message = D.19357;
    vinfo->exception_type = 3;
    D.19348 = ctx->errors;
    D.19358 = monoeg_g_slist_prepend (D.19348, vinfo);
    ctx->errors = D.19358;
  }
  <D.19356>:
  ctx->valid = 0;
  return;
  <D.19351>:
  D.19359 = mono_read16 (pe_optional_header);
  if (D.19359 == 267) goto <D.19360>; else goto <D.19361>;
  <D.19360>:
  if (header_size != 224) goto <D.19362>; else goto <D.19363>;
  <D.19362>:
  D.19344 = ctx->report_error;
  if (D.19344 != 0) goto <D.19364>; else goto <D.19365>;
  <D.19364>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19366 = monoeg_g_strdup_printf ("Invalid optional header size %d", header_size);
    vinfo->info.message = D.19366;
    vinfo->exception_type = 3;
    D.19348 = ctx->errors;
    D.19367 = monoeg_g_slist_prepend (D.19348, vinfo);
    ctx->errors = D.19367;
  }
  <D.19365>:
  ctx->valid = 0;
  return;
  <D.19363>:
  D.19368 = pe_optional_header + 32;
  D.19369 = mono_read32 (D.19368);
  if (D.19369 != 8192) goto <D.19370>; else goto <D.19371>;
  <D.19370>:
  D.19344 = ctx->report_error;
  if (D.19344 != 0) goto <D.19372>; else goto <D.19373>;
  <D.19372>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19368 = pe_optional_header + 32;
    D.19374 = mono_read32 (D.19368);
    D.19375 = monoeg_g_strdup_printf ("Invalid Section Aligmnent %x", D.19374);
    vinfo->info.message = D.19375;
    vinfo->exception_type = 3;
    D.19348 = ctx->errors;
    D.19376 = monoeg_g_slist_prepend (D.19348, vinfo);
    ctx->errors = D.19376;
  }
  <D.19373>:
  ctx->valid = 0;
  return;
  <D.19371>:
  D.19377 = pe_optional_header + 36;
  file_alignment = mono_read32 (D.19377);
  if (file_alignment != 512) goto <D.19378>; else goto <D.19379>;
  <D.19378>:
  if (file_alignment != 4096) goto <D.19380>; else goto <D.19381>;
  <D.19380>:
  D.19344 = ctx->report_error;
  if (D.19344 != 0) goto <D.19382>; else goto <D.19383>;
  <D.19382>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19384 = monoeg_g_strdup_printf ("Invalid file Aligmnent %x", file_alignment);
    vinfo->info.message = D.19384;
    vinfo->exception_type = 3;
    D.19348 = ctx->errors;
    D.19385 = monoeg_g_slist_prepend (D.19348, vinfo);
    ctx->errors = D.19385;
  }
  <D.19383>:
  ctx->valid = 0;
  return;
  <D.19381>:
  <D.19379>:
  D.19386 = pe_optional_header + 92;
  D.19387 = mono_read32 (D.19386);
  if (D.19387 > 16) goto <D.19388>; else goto <D.19389>;
  <D.19388>:
  D.19344 = ctx->report_error;
  if (D.19344 != 0) goto <D.19390>; else goto <D.19391>;
  <D.19390>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19386 = pe_optional_header + 92;
    D.19392 = mono_read32 (D.19386);
    D.19393 = monoeg_g_strdup_printf ("Too many data directories %x", D.19392);
    vinfo->info.message = D.19393;
    vinfo->exception_type = 3;
    D.19348 = ctx->errors;
    D.19394 = monoeg_g_slist_prepend (D.19348, vinfo);
    ctx->errors = D.19394;
  }
  <D.19391>:
  ctx->valid = 0;
  return;
  <D.19389>:
  goto <D.19395>;
  <D.19361>:
  D.19396 = mono_read16 (pe_optional_header);
  if (D.19396 == 523) goto <D.19397>; else goto <D.19398>;
  <D.19397>:
  D.19344 = ctx->report_error;
  if (D.19344 != 0) goto <D.19399>; else goto <D.19400>;
  <D.19399>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19401 = monoeg_strdup ("Metadata verifier doesn\'t handle PE32+");
    vinfo->info.message = D.19401;
    vinfo->exception_type = 3;
    D.19348 = ctx->errors;
    D.19402 = monoeg_g_slist_prepend (D.19348, vinfo);
    ctx->errors = D.19402;
  }
  <D.19400>:
  ctx->valid = 0;
  return;
  <D.19398>:
  D.19344 = ctx->report_error;
  if (D.19344 != 0) goto <D.19403>; else goto <D.19404>;
  <D.19403>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19405 = mono_read16 (pe_optional_header);
    D.19406 = (int) D.19405;
    D.19407 = monoeg_g_strdup_printf ("Invalid optional header magic %d", D.19406);
    vinfo->info.message = D.19407;
    vinfo->exception_type = 3;
    D.19348 = ctx->errors;
    D.19408 = monoeg_g_slist_prepend (D.19348, vinfo);
    ctx->errors = D.19408;
  }
  <D.19404>:
  ctx->valid = 0;
  return;
  <D.19395>:
}


pe_header_offset (struct VerifyContext * ctx)
{
  guint32 D.19410;
  const char * D.19411;
  const unsigned char * D.19412;
  unsigned int D.19413;

  D.19411 = ctx->data;
  D.19412 = D.19411 + 60;
  D.19413 = mono_read32 (D.19412);
  D.19410 = D.19413 + 4;
  return D.19410;
}


load_section_table (struct VerifyContext * ctx)
{
  const char * D.19415;
  const unsigned char * D.19416;
  short unsigned int D.19417;
  unsigned int D.19418;
  unsigned int D.19419;
  int D.19420;
  int D.19421;
  unsigned int D.19422;
  unsigned int D.19423;
  unsigned int D.19424;
  int D.19427;
  gchar * D.19430;
  struct GSList * D.19431;
  struct GSList * D.19432;
  unsigned int D.19433;
  unsigned int D.19434;
  void * D.19435;
  unsigned int i.0;
  unsigned int D.19437;
  struct SectionHeader * D.19438;
  const unsigned char * D.19439;
  unsigned int D.19440;
  const unsigned char * D.19441;
  unsigned int D.19442;
  const unsigned char * D.19443;
  unsigned int D.19444;
  const unsigned char * D.19445;
  unsigned int D.19446;
  const unsigned char * D.19447;
  short unsigned int D.19448;
  unsigned int D.19449;
  gchar * D.19454;
  struct GSList * D.19455;
  gchar * D.19460;
  struct GSList * D.19461;
  unsigned int D.19462;
  unsigned int D.19463;
  gchar * D.19468;
  struct GSList * D.19469;
  const unsigned char * D.19470;
  gchar * D.19475;
  struct GSList * D.19476;
  gchar * D.19481;
  struct GSList * D.19482;
  unsigned int D.19485;
  short unsigned int D.19487;
  gchar * D.19490;
  struct GSList * D.19491;
  const unsigned char * D.19492;
  unsigned int D.19496;
  gchar * D.19499;
  struct GSList * D.19500;
  int i;
  struct SectionHeader * sections;
  guint32 offset;
  const char * ptr;
  guint16 num_sections;

  offset = pe_header_offset (ctx);
  D.19415 = ctx->data;
  ptr = D.19415 + offset;
  D.19416 = ptr + 2;
  D.19417 = mono_read16 (D.19416);
  D.19418 = (unsigned int) D.19417;
  ctx->section_count = D.19418;
  D.19419 = ctx->section_count;
  num_sections = (guint16) D.19419;
  offset = offset + 244;
  ptr = ptr + 244;
  D.19420 = (int) num_sections;
  D.19421 = D.19420 * 40;
  D.19422 = (unsigned int) D.19421;
  D.19423 = ctx->size;
  D.19424 = D.19423 - offset;
  if (D.19422 > D.19424) goto <D.19425>; else goto <D.19426>;
  <D.19425>:
  D.19427 = ctx->report_error;
  if (D.19427 != 0) goto <D.19428>; else goto <D.19429>;
  <D.19428>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19430 = monoeg_strdup ("Invalid PE optional header size");
    vinfo->info.message = D.19430;
    vinfo->exception_type = 3;
    D.19431 = ctx->errors;
    D.19432 = monoeg_g_slist_prepend (D.19431, vinfo);
    ctx->errors = D.19432;
  }
  <D.19429>:
  ctx->valid = 0;
  return;
  <D.19426>:
  D.19433 = (unsigned int) num_sections;
  D.19434 = D.19433 * 20;
  D.19435 = monoeg_malloc0 (D.19434);
  ctx->sections = D.19435;
  sections = ctx->sections;
  i = 0;
  goto <D.17428>;
  <D.17427>:
  i.0 = (unsigned int) i;
  D.19437 = i.0 * 20;
  D.19438 = sections + D.19437;
  D.19439 = ptr + 8;
  D.19440 = mono_read32 (D.19439);
  D.19438->size = D.19440;
  i.0 = (unsigned int) i;
  D.19437 = i.0 * 20;
  D.19438 = sections + D.19437;
  D.19441 = ptr + 12;
  D.19442 = mono_read32 (D.19441);
  D.19438->baseRVA = D.19442;
  i.0 = (unsigned int) i;
  D.19437 = i.0 * 20;
  D.19438 = sections + D.19437;
  D.19443 = ptr + 20;
  D.19444 = mono_read32 (D.19443);
  D.19438->baseOffset = D.19444;
  i.0 = (unsigned int) i;
  D.19437 = i.0 * 20;
  D.19438 = sections + D.19437;
  D.19445 = ptr + 24;
  D.19446 = mono_read32 (D.19445);
  D.19438->rellocationsRVA = D.19446;
  i.0 = (unsigned int) i;
  D.19437 = i.0 * 20;
  D.19438 = sections + D.19437;
  D.19447 = ptr + 32;
  D.19448 = mono_read16 (D.19447);
  D.19438->numberOfRelocations = D.19448;
  ptr = ptr + 40;
  i = i + 1;
  <D.17428>:
  D.19420 = (int) num_sections;
  if (D.19420 > i) goto <D.17427>; else goto <D.17429>;
  <D.17429>:
  D.19415 = ctx->data;
  ptr = D.19415 + offset;
  i = 0;
  goto <D.17440>;
  <D.17439>:
  {
    guint32 raw_size;
    guint32 flags;

    i.0 = (unsigned int) i;
    D.19437 = i.0 * 20;
    D.19438 = sections + D.19437;
    D.19449 = D.19438->baseOffset;
    if (D.19449 == 0) goto <D.19450>; else goto <D.19451>;
    <D.19450>:
    D.19427 = ctx->report_error;
    if (D.19427 != 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 ("Metadata verifier doesn\'t handle sections with intialized data only");
      vinfo->info.message = D.19454;
      vinfo->exception_type = 3;
      D.19431 = ctx->errors;
      D.19455 = monoeg_g_slist_prepend (D.19431, vinfo);
      ctx->errors = D.19455;
    }
    <D.19453>:
    ctx->valid = 0;
    return;
    <D.19451>:
    i.0 = (unsigned int) i;
    D.19437 = i.0 * 20;
    D.19438 = sections + D.19437;
    D.19449 = D.19438->baseOffset;
    D.19423 = ctx->size;
    if (D.19449 >= D.19423) goto <D.19456>; else goto <D.19457>;
    <D.19456>:
    D.19427 = ctx->report_error;
    if (D.19427 != 0) goto <D.19458>; else goto <D.19459>;
    <D.19458>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      i.0 = (unsigned int) i;
      D.19437 = i.0 * 20;
      D.19438 = sections + D.19437;
      D.19449 = D.19438->baseOffset;
      D.19460 = monoeg_g_strdup_printf ("Invalid PointerToRawData %x points beyond EOF", D.19449);
      vinfo->info.message = D.19460;
      vinfo->exception_type = 3;
      D.19431 = ctx->errors;
      D.19461 = monoeg_g_slist_prepend (D.19431, vinfo);
      ctx->errors = D.19461;
    }
    <D.19459>:
    ctx->valid = 0;
    return;
    <D.19457>:
    i.0 = (unsigned int) i;
    D.19437 = i.0 * 20;
    D.19438 = sections + D.19437;
    D.19462 = D.19438->size;
    D.19423 = ctx->size;
    i.0 = (unsigned int) i;
    D.19437 = i.0 * 20;
    D.19438 = sections + D.19437;
    D.19449 = D.19438->baseOffset;
    D.19463 = D.19423 - D.19449;
    if (D.19462 > D.19463) goto <D.19464>; else goto <D.19465>;
    <D.19464>:
    D.19427 = ctx->report_error;
    if (D.19427 != 0) goto <D.19466>; else goto <D.19467>;
    <D.19466>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.19468 = monoeg_strdup ("Invalid VirtualSize points beyond EOF");
      vinfo->info.message = D.19468;
      vinfo->exception_type = 3;
      D.19431 = ctx->errors;
      D.19469 = monoeg_g_slist_prepend (D.19431, vinfo);
      ctx->errors = D.19469;
    }
    <D.19467>:
    ctx->valid = 0;
    return;
    <D.19465>:
    D.19470 = ptr + 16;
    raw_size = mono_read32 (D.19470);
    i.0 = (unsigned int) i;
    D.19437 = i.0 * 20;
    D.19438 = sections + D.19437;
    D.19462 = D.19438->size;
    if (D.19462 > raw_size) goto <D.19471>; else goto <D.19472>;
    <D.19471>:
    D.19427 = ctx->report_error;
    if (D.19427 != 0) goto <D.19473>; else goto <D.19474>;
    <D.19473>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.19475 = monoeg_strdup ("Metadata verifier doesn\'t handle sections with SizeOfRawData < VirtualSize");
      vinfo->info.message = D.19475;
      vinfo->exception_type = 3;
      D.19431 = ctx->errors;
      D.19476 = monoeg_g_slist_prepend (D.19431, vinfo);
      ctx->errors = D.19476;
    }
    <D.19474>:
    ctx->valid = 0;
    return;
    <D.19472>:
    D.19423 = ctx->size;
    i.0 = (unsigned int) i;
    D.19437 = i.0 * 20;
    D.19438 = sections + D.19437;
    D.19449 = D.19438->baseOffset;
    D.19463 = D.19423 - D.19449;
    if (D.19463 < raw_size) goto <D.19477>; else goto <D.19478>;
    <D.19477>:
    D.19427 = ctx->report_error;
    if (D.19427 != 0) goto <D.19479>; else goto <D.19480>;
    <D.19479>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.19481 = monoeg_g_strdup_printf ("Invalid SizeOfRawData %x points beyond EOF", raw_size);
      vinfo->info.message = D.19481;
      vinfo->exception_type = 3;
      D.19431 = ctx->errors;
      D.19482 = monoeg_g_slist_prepend (D.19431, vinfo);
      ctx->errors = D.19482;
    }
    <D.19480>:
    ctx->valid = 0;
    return;
    <D.19478>:
    i.0 = (unsigned int) i;
    D.19437 = i.0 * 20;
    D.19438 = sections + D.19437;
    D.19485 = D.19438->rellocationsRVA;
    if (D.19485 != 0) goto <D.19483>; else goto <D.19486>;
    <D.19486>:
    i.0 = (unsigned int) i;
    D.19437 = i.0 * 20;
    D.19438 = sections + D.19437;
    D.19487 = D.19438->numberOfRelocations;
    if (D.19487 != 0) goto <D.19483>; else goto <D.19484>;
    <D.19483>:
    D.19427 = ctx->report_error;
    if (D.19427 != 0) goto <D.19488>; else goto <D.19489>;
    <D.19488>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.19490 = monoeg_g_strdup_printf ("Metadata verifier doesn\'t handle section relocation");
      vinfo->info.message = D.19490;
      vinfo->exception_type = 3;
      D.19431 = ctx->errors;
      D.19491 = monoeg_g_slist_prepend (D.19431, vinfo);
      ctx->errors = D.19491;
    }
    <D.19489>:
    ctx->valid = 0;
    return;
    <D.19484>:
    D.19492 = ptr + 36;
    flags = mono_read32 (D.19492);
    if (flags == 0) goto <D.19493>; else goto <D.19495>;
    <D.19495>:
    D.19496 = flags & 33554207;
    if (D.19496 != 0) goto <D.19493>; else goto <D.19494>;
    <D.19493>:
    D.19427 = ctx->report_error;
    if (D.19427 != 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 section flags %x", flags);
      vinfo->info.message = D.19499;
      vinfo->exception_type = 3;
      D.19431 = ctx->errors;
      D.19500 = monoeg_g_slist_prepend (D.19431, vinfo);
      ctx->errors = D.19500;
    }
    <D.19498>:
    ctx->valid = 0;
    return;
    <D.19494>:
    ptr = ptr + 40;
  }
  i = i + 1;
  <D.17440>:
  D.19420 = (int) num_sections;
  if (D.19420 > i) goto <D.17439>; else goto <D.17441>;
  <D.17441>:
}


load_data_directories (struct VerifyContext * ctx)
{
  unsigned int D.19502;
  const char * D.19503;
  const unsigned char * D.19504;
  int D.19510;
  int D.19513;
  gchar * D.19516;
  struct GSList * D.19517;
  struct GSList * D.19518;
  int D.19521;
  gchar * D.19526;
  struct GSList * D.19527;
  unsigned int D.19528;
  guint32 offset;
  const char * ptr;
  int i;

  D.19502 = pe_header_offset (ctx);
  offset = D.19502 + 116;
  D.19503 = ctx->data;
  ptr = D.19503 + offset;
  i = 0;
  goto <D.17457>;
  <D.17456>:
  {
    guint32 rva;
    guint32 size;

    rva = mono_read32 (ptr);
    D.19504 = ptr + 4;
    size = mono_read32 (D.19504);
    if (i == 4) goto <D.19505>; else goto <D.19506>;
    <D.19505>:
    ptr = ptr + 8;
    // predicted unlikely by continue predictor.
    goto <D.17453>;
    <D.19506>:
    if (rva != 0) goto <D.19507>; else goto <D.19509>;
    <D.19509>:
    if (size != 0) goto <D.19507>; else goto <D.19508>;
    <D.19507>:
    D.19510 = is_valid_data_directory (i);
    if (D.19510 == 0) goto <D.19511>; else goto <D.19512>;
    <D.19511>:
    D.19513 = ctx->report_error;
    if (D.19513 != 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 data directory %d", i);
      vinfo->info.message = D.19516;
      vinfo->exception_type = 3;
      D.19517 = ctx->errors;
      D.19518 = monoeg_g_slist_prepend (D.19517, vinfo);
      ctx->errors = D.19518;
    }
    <D.19515>:
    ctx->valid = 0;
    return;
    <D.19512>:
    <D.19508>:
    if (rva != 0) goto <D.19519>; else goto <D.19520>;
    <D.19519>:
    D.19521 = bounds_check_virtual_address (ctx, rva, size);
    if (D.19521 == 0) goto <D.19522>; else goto <D.19523>;
    <D.19522>:
    D.19513 = ctx->report_error;
    if (D.19513 != 0) goto <D.19524>; else goto <D.19525>;
    <D.19524>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.19526 = monoeg_g_strdup_printf ("Invalid data directory %d rva/size pair %x/%x", i, rva, size);
      vinfo->info.message = D.19526;
      vinfo->exception_type = 3;
      D.19517 = ctx->errors;
      D.19527 = monoeg_g_slist_prepend (D.19517, vinfo);
      ctx->errors = D.19527;
    }
    <D.19525>:
    ctx->valid = 0;
    return;
    <D.19523>:
    <D.19520>:
    ctx->data_directories[i].rva = rva;
    ctx->data_directories[i].size = size;
    D.19528 = translate_rva (ctx, rva);
    ctx->data_directories[i].translated_offset = D.19528;
    ptr = ptr + 8;
  }
  <D.17453>:
  i = i + 1;
  <D.17457>:
  if (i <= 15) goto <D.17456>; else goto <D.17458>;
  <D.17458>:
}


is_valid_data_directory (int i)
{
  gboolean D.19530;
  int iftmp.1;
  unsigned int i.2;
  unsigned int D.19536;

  i.2 = (unsigned int) i;
  D.19536 = i.2 + 4294967295;
  if (D.19536 <= 1) goto <D.19532>; else goto <D.19537>;
  <D.19537>:
  if (i == 5) goto <D.19532>; else goto <D.19538>;
  <D.19538>:
  if (i == 12) goto <D.19532>; else goto <D.19539>;
  <D.19539>:
  if (i == 14) goto <D.19532>; else goto <D.19540>;
  <D.19540>:
  if (i == 4) goto <D.19532>; else goto <D.19541>;
  <D.19541>:
  if (i == 6) goto <D.19532>; else goto <D.19533>;
  <D.19532>:
  iftmp.1 = 1;
  goto <D.19534>;
  <D.19533>:
  iftmp.1 = 0;
  <D.19534>:
  D.19530 = iftmp.1;
  return D.19530;
}


bounds_check_virtual_address (struct VerifyContext * ctx, guint32 rva, guint32 size)
{
  unsigned int D.19543;
  gboolean D.19546;
  int D.19547;
  struct MonoImage * D.19550;
  unsigned int D.19551;
  struct SectionHeader * D.19556;
  unsigned int i.3;
  unsigned int D.19560;
  struct SectionHeader * D.19561;
  unsigned int D.19562;
  unsigned int D.19563;
  unsigned int i.4;
  unsigned int D.19569;
  int i;

  D.19543 = rva + size;
  if (D.19543 < rva) goto <D.19544>; else goto <D.19545>;
  <D.19544>:
  D.19546 = 0;
  return D.19546;
  <D.19545>:
  D.19547 = ctx->stage;
  if (D.19547 > 0) goto <D.19548>; else goto <D.19549>;
  <D.19548>:
  {
    struct MonoCLIImageInfo * iinfo;
    const int top;
    struct MonoSectionTable * tables;
    int i;

    D.19550 = ctx->image;
    iinfo = D.19550->image_info;
    top = iinfo->cli_section_count;
    tables = iinfo->cli_section_tables;
    i = 0;
    goto <D.17359>;
    <D.17358>:
    {
      guint32 base;
      guint32 end;

      base = tables->st_virtual_address;
      D.19551 = tables->st_raw_data_size;
      end = D.19551 + base;
      if (rva >= base) goto <D.19552>; else goto <D.19553>;
      <D.19552>:
      D.19543 = rva + size;
      if (D.19543 <= end) goto <D.19554>; else goto <D.19555>;
      <D.19554>:
      D.19546 = 1;
      return D.19546;
      <D.19555>:
      <D.19553>:
      tables = tables + 40;
    }
    i = i + 1;
    <D.17359>:
    if (i < top) goto <D.17358>; else goto <D.17360>;
    <D.17360>:
    D.19546 = 0;
    return D.19546;
  }
  <D.19549>:
  D.19556 = ctx->sections;
  if (D.19556 == 0B) goto <D.19557>; else goto <D.19558>;
  <D.19557>:
  D.19546 = 0;
  return D.19546;
  <D.19558>:
  i = 0;
  goto <D.17364>;
  <D.17363>:
  {
    guint32 base;
    guint32 end;

    D.19556 = ctx->sections;
    i.3 = (unsigned int) i;
    D.19560 = i.3 * 20;
    D.19561 = D.19556 + D.19560;
    base = D.19561->baseRVA;
    D.19556 = ctx->sections;
    i.3 = (unsigned int) i;
    D.19560 = i.3 * 20;
    D.19561 = D.19556 + D.19560;
    D.19562 = D.19561->baseRVA;
    D.19556 = ctx->sections;
    i.3 = (unsigned int) i;
    D.19560 = i.3 * 20;
    D.19561 = D.19556 + D.19560;
    D.19563 = D.19561->size;
    end = D.19562 + D.19563;
    if (rva >= base) goto <D.19564>; else goto <D.19565>;
    <D.19564>:
    D.19543 = rva + size;
    if (D.19543 <= end) goto <D.19566>; else goto <D.19567>;
    <D.19566>:
    D.19546 = 1;
    return D.19546;
    <D.19567>:
    <D.19565>:
  }
  i = i + 1;
  <D.17364>:
  i.4 = (unsigned int) i;
  D.19569 = ctx->section_count;
  if (i.4 < D.19569) goto <D.17363>; else goto <D.17365>;
  <D.17365>:
  D.19546 = 0;
  return D.19546;
}


translate_rva (struct VerifyContext * ctx, guint32 rva)
{
  int D.19571;
  guint32 D.19574;
  struct MonoImage * D.19575;
  struct SectionHeader * D.19576;
  unsigned int i.5;
  unsigned int D.19580;
  struct SectionHeader * D.19581;
  unsigned int D.19582;
  unsigned int D.19583;
  unsigned int D.19588;
  unsigned int D.19589;
  guint32 iftmp.6;
  unsigned int D.19591;
  unsigned int i.7;
  unsigned int D.19596;
  int i;

  D.19571 = ctx->stage;
  if (D.19571 > 0) goto <D.19572>; else goto <D.19573>;
  <D.19572>:
  D.19575 = ctx->image;
  D.19574 = mono_cli_rva_image_map (D.19575, rva);
  return D.19574;
  <D.19573>:
  D.19576 = ctx->sections;
  if (D.19576 == 0B) goto <D.19577>; else goto <D.19578>;
  <D.19577>:
  D.19574 = 0;
  return D.19574;
  <D.19578>:
  i = 0;
  goto <D.17385>;
  <D.17384>:
  {
    guint32 base;
    guint32 end;

    D.19576 = ctx->sections;
    i.5 = (unsigned int) i;
    D.19580 = i.5 * 20;
    D.19581 = D.19576 + D.19580;
    base = D.19581->baseRVA;
    D.19576 = ctx->sections;
    i.5 = (unsigned int) i;
    D.19580 = i.5 * 20;
    D.19581 = D.19576 + D.19580;
    D.19582 = D.19581->baseRVA;
    D.19576 = ctx->sections;
    i.5 = (unsigned int) i;
    D.19580 = i.5 * 20;
    D.19581 = D.19576 + D.19580;
    D.19583 = D.19581->size;
    end = D.19582 + D.19583;
    if (rva >= base) goto <D.19584>; else goto <D.19585>;
    <D.19584>:
    if (rva <= end) goto <D.19586>; else goto <D.19587>;
    <D.19586>:
    {
      guint32 res;

      D.19588 = rva - base;
      D.19576 = ctx->sections;
      i.5 = (unsigned int) i;
      D.19580 = i.5 * 20;
      D.19581 = D.19576 + D.19580;
      D.19589 = D.19581->baseOffset;
      res = D.19588 + D.19589;
      D.19591 = ctx->size;
      if (D.19591 > res) goto <D.19592>; else goto <D.19593>;
      <D.19592>:
      iftmp.6 = res;
      goto <D.19594>;
      <D.19593>:
      iftmp.6 = 4294967295;
      <D.19594>:
      D.19574 = iftmp.6;
      return D.19574;
    }
    <D.19587>:
    <D.19585>:
  }
  i = i + 1;
  <D.17385>:
  i.7 = (unsigned int) i;
  D.19596 = ctx->section_count;
  if (i.7 < D.19596) goto <D.17384>; else goto <D.17386>;
  <D.17386>:
  D.19574 = 4294967295;
  return D.19574;
}


verify_import_table (struct VerifyContext * ctx)
{
  const char * D.19598;
  _Bool D.19599;
  long int D.19600;
  long int D.19601;
  unsigned int D.19604;
  int D.19607;
  gchar * D.19610;
  struct GSList * D.19611;
  struct GSList * D.19612;
  int D.19615;
  gchar * D.19620;
  struct GSList * D.19621;
  const unsigned char * D.19622;
  int D.19625;
  gchar * D.19630;
  struct GSList * D.19631;
  const unsigned char * D.19632;
  int D.19635;
  gchar * D.19640;
  struct GSList * D.19641;
  unsigned int D.19642;
  unsigned int D.19647;
  gchar * D.19648;
  struct GSList * D.19649;
  _Bool D.19652;
  long int D.19653;
  long int D.19654;
  int D.19657;
  gchar * D.19662;
  struct GSList * D.19663;
  int D.19666;
  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.19598 = ctx->data;
      ptr = D.19598 + offset;
      D.19599 = offset == 4294967295;
      D.19600 = (long int) D.19599;
      D.19601 = __builtin_expect (D.19600, 0);
      if (D.19601 != 0) goto <D.19602>; else goto <D.19603>;
      <D.19602>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 612, "offset != INVALID_OFFSET");
      <D.19603>:
      D.19604 = it.size;
      if (D.19604 <= 39) goto <D.19605>; else goto <D.19606>;
      <D.19605>:
      D.19607 = ctx->report_error;
      if (D.19607 != 0) goto <D.19608>; else goto <D.19609>;
      <D.19608>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19604 = it.size;
        D.19610 = monoeg_g_strdup_printf ("Import table size %d is smaller than 40", D.19604);
        vinfo->info.message = D.19610;
        vinfo->exception_type = 3;
        D.19611 = ctx->errors;
        D.19612 = monoeg_g_slist_prepend (D.19611, vinfo);
        ctx->errors = D.19612;
      }
      <D.19609>:
      ctx->valid = 0;
      return;
      <D.19606>:
      ilt_rva = mono_read32 (ptr);
      if (ilt_rva != 0) goto <D.19613>; else goto <D.19614>;
      <D.19613>:
      D.19615 = bounds_check_virtual_address (ctx, ilt_rva, 8);
      if (D.19615 == 0) goto <D.19616>; else goto <D.19617>;
      <D.19616>:
      D.19607 = ctx->report_error;
      if (D.19607 != 0) goto <D.19618>; else goto <D.19619>;
      <D.19618>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19620 = monoeg_g_strdup_printf ("Invalid Import Lookup Table rva %x", ilt_rva);
        vinfo->info.message = D.19620;
        vinfo->exception_type = 3;
        D.19611 = ctx->errors;
        D.19621 = monoeg_g_slist_prepend (D.19611, vinfo);
        ctx->errors = D.19621;
      }
      <D.19619>:
      ctx->valid = 0;
      return;
      <D.19617>:
      <D.19614>:
      D.19622 = ptr + 12;
      name_rva = mono_read32 (D.19622);
      if (name_rva != 0) goto <D.19623>; else goto <D.19624>;
      <D.19623>:
      D.19625 = bounds_check_virtual_address (ctx, name_rva, 12);
      if (D.19625 == 0) goto <D.19626>; else goto <D.19627>;
      <D.19626>:
      D.19607 = ctx->report_error;
      if (D.19607 != 0) goto <D.19628>; else goto <D.19629>;
      <D.19628>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19630 = monoeg_g_strdup_printf ("Invalid Import Table Name rva %x", name_rva);
        vinfo->info.message = D.19630;
        vinfo->exception_type = 3;
        D.19611 = ctx->errors;
        D.19631 = monoeg_g_slist_prepend (D.19611, vinfo);
        ctx->errors = D.19631;
      }
      <D.19629>:
      ctx->valid = 0;
      return;
      <D.19627>:
      <D.19624>:
      D.19632 = ptr + 16;
      iat_rva = mono_read32 (D.19632);
      if (iat_rva != 0) goto <D.19633>; else goto <D.19634>;
      <D.19633>:
      D.19635 = bounds_check_virtual_address (ctx, iat_rva, 8);
      if (D.19635 == 0) goto <D.19636>; else goto <D.19637>;
      <D.19636>:
      D.19607 = ctx->report_error;
      if (D.19607 != 0) goto <D.19638>; else goto <D.19639>;
      <D.19638>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19640 = monoeg_g_strdup_printf ("Invalid Import Address Table rva %x", iat_rva);
        vinfo->info.message = D.19640;
        vinfo->exception_type = 3;
        D.19611 = ctx->errors;
        D.19641 = monoeg_g_slist_prepend (D.19611, vinfo);
        ctx->errors = D.19641;
      }
      <D.19639>:
      ctx->valid = 0;
      return;
      <D.19637>:
      D.19642 = ctx->data_directories[12].rva;
      if (D.19642 != iat_rva) goto <D.19643>; else goto <D.19644>;
      <D.19643>:
      D.19607 = ctx->report_error;
      if (D.19607 != 0) goto <D.19645>; else goto <D.19646>;
      <D.19645>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19632 = ptr + 16;
        D.19647 = mono_read32 (D.19632);
        D.19642 = ctx->data_directories[12].rva;
        D.19648 = monoeg_g_strdup_printf ("Import Address Table rva %x different from data directory entry %x", D.19647, D.19642);
        vinfo->info.message = D.19648;
        vinfo->exception_type = 3;
        D.19611 = ctx->errors;
        D.19649 = monoeg_g_slist_prepend (D.19611, vinfo);
        ctx->errors = D.19649;
      }
      <D.19646>:
      ctx->valid = 0;
      return;
      <D.19644>:
      <D.19634>:
      if (name_rva != 0) goto <D.19650>; else goto <D.19651>;
      <D.19650>:
      name_rva = translate_rva (ctx, name_rva);
      D.19652 = name_rva == 4294967295;
      D.19653 = (long int) D.19652;
      D.19654 = __builtin_expect (D.19653, 0);
      if (D.19654 != 0) goto <D.19655>; else goto <D.19656>;
      <D.19655>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 636, "name_rva != INVALID_OFFSET");
      <D.19656>:
      D.19598 = ctx->data;
      ptr = D.19598 + name_rva;
      D.19657 = memcmp ("mscoree.dll", ptr, 12);
      if (D.19657 != 0) goto <D.19658>; else goto <D.19659>;
      <D.19658>:
      {
        char name[12];

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

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.19662 = monoeg_g_strdup_printf ("Invalid Import Table Name: \'%s\'", &name);
              vinfo->info.message = D.19662;
              vinfo->exception_type = 3;
              D.19611 = ctx->errors;
              D.19663 = monoeg_g_slist_prepend (D.19611, vinfo);
              ctx->errors = D.19663;
            }
            <D.19661>:
            ctx->valid = 0;
            return;
          }
        finally
          {
            name = {CLOBBER};
          }
      }
      <D.19659>:
      <D.19651>:
      if (ilt_rva != 0) goto <D.19664>; else goto <D.19665>;
      <D.19664>:
      verify_hint_name_table (ctx, ilt_rva, "Import Lookup Table");
      D.19666 = ctx->valid;
      if (D.19666 == 0) goto <D.19667>; else goto <D.19668>;
      <D.19667>:
      return;
      <D.19668>:
      <D.19665>:
      if (iat_rva != 0) goto <D.19669>; else goto <D.19670>;
      <D.19669>:
      verify_hint_name_table (ctx, iat_rva, "Import Address Table");
      <D.19670>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


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

  D.19676 = __builtin_object_size (__dest, 0);
  D.19675 = __builtin___memcpy_chk (__dest, __src, __len, D.19676);
  return D.19675;
}


verify_hint_name_table (struct VerifyContext * ctx, guint32 import_rva, const char * table_name)
{
  _Bool D.19678;
  long int D.19679;
  long int D.19680;
  const char * D.19683;
  const unsigned char * D.19684;
  int D.19685;
  int D.19688;
  gchar * D.19691;
  struct GSList * D.19692;
  struct GSList * D.19693;
  _Bool D.19694;
  long int D.19695;
  long int D.19696;
  sizetype D.19699;
  int D.19700;
  int D.19703;
  gchar * D.19708;
  struct GSList * D.19709;
  const char * ptr;
  guint32 hint_table_rva;

  import_rva = translate_rva (ctx, import_rva);
  D.19678 = import_rva == 4294967295;
  D.19679 = (long int) D.19678;
  D.19680 = __builtin_expect (D.19679, 0);
  if (D.19680 != 0) goto <D.19681>; else goto <D.19682>;
  <D.19681>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 586, "import_rva != INVALID_OFFSET");
  <D.19682>:
  D.19683 = ctx->data;
  D.19684 = D.19683 + import_rva;
  hint_table_rva = mono_read32 (D.19684);
  D.19685 = bounds_check_virtual_address (ctx, hint_table_rva, 14);
  if (D.19685 == 0) goto <D.19686>; else goto <D.19687>;
  <D.19686>:
  D.19688 = ctx->report_error;
  if (D.19688 != 0) goto <D.19689>; else goto <D.19690>;
  <D.19689>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.19691 = monoeg_g_strdup_printf ("Invalid Hint/Name rva %d for %s", hint_table_rva, table_name);
    vinfo->info.message = D.19691;
    vinfo->exception_type = 3;
    D.19692 = ctx->errors;
    D.19693 = monoeg_g_slist_prepend (D.19692, vinfo);
    ctx->errors = D.19693;
  }
  <D.19690>:
  ctx->valid = 0;
  return;
  <D.19687>:
  hint_table_rva = translate_rva (ctx, hint_table_rva);
  D.19694 = hint_table_rva == 4294967295;
  D.19695 = (long int) D.19694;
  D.19696 = __builtin_expect (D.19695, 0);
  if (D.19696 != 0) goto <D.19697>; else goto <D.19698>;
  <D.19697>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 593, "hint_table_rva != INVALID_OFFSET");
  <D.19698>:
  D.19683 = ctx->data;
  D.19699 = hint_table_rva + 2;
  ptr = D.19683 + D.19699;
  D.19700 = memcmp ("_CorExeMain", ptr, 12);
  if (D.19700 != 0) goto <D.19701>; else goto <D.19702>;
  <D.19701>:
  D.19703 = memcmp ("_CorDllMain", ptr, 12);
  if (D.19703 != 0) goto <D.19704>; else goto <D.19705>;
  <D.19704>:
  {
    char name[12];

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

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.19708 = monoeg_g_strdup_printf ("Invalid Hint / Name: \'%s\'", &name);
          vinfo->info.message = D.19708;
          vinfo->exception_type = 3;
          D.19692 = ctx->errors;
          D.19709 = monoeg_g_slist_prepend (D.19692, vinfo);
          ctx->errors = D.19709;
        }
        <D.19707>:
        ctx->valid = 0;
        return;
      }
    finally
      {
        name = {CLOBBER};
      }
  }
  <D.19705>:
  <D.19702>:
}


verify_resources_table (struct VerifyContext * ctx)
{
  unsigned int D.19712;
  unsigned int D.19715;
  int D.19718;
  gchar * D.19721;
  struct GSList * D.19722;
  struct GSList * D.19723;
  const char * D.19724;
  _Bool D.19725;
  long int D.19726;
  long int D.19727;
  const unsigned char * D.19730;
  const unsigned char * D.19731;
  int D.19732;
  int D.19733;
  int D.19734;
  int D.19735;
  int D.19736;
  unsigned int D.19737;
  gchar * D.19742;
  struct GSList * D.19743;
  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.19712 = it.rva;
      if (D.19712 == 0) goto <D.19713>; else goto <D.19714>;
      <D.19713>:
      return;
      <D.19714>:
      D.19715 = it.size;
      if (D.19715 <= 15) goto <D.19716>; else goto <D.19717>;
      <D.19716>:
      D.19718 = ctx->report_error;
      if (D.19718 != 0) goto <D.19719>; else goto <D.19720>;
      <D.19719>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19715 = it.size;
        D.19721 = monoeg_g_strdup_printf ("Resource section is too small, must be at least 16 bytes long but it\'s %d long", D.19715);
        vinfo->info.message = D.19721;
        vinfo->exception_type = 3;
        D.19722 = ctx->errors;
        D.19723 = monoeg_g_slist_prepend (D.19722, vinfo);
        ctx->errors = D.19723;
      }
      <D.19720>:
      ctx->valid = 0;
      return;
      <D.19717>:
      offset = it.translated_offset;
      D.19724 = ctx->data;
      ptr = D.19724 + offset;
      root = ptr;
      D.19715 = it.size;
      end = root + D.19715;
      D.19725 = offset == 4294967295;
      D.19726 = (long int) D.19725;
      D.19727 = __builtin_expect (D.19726, 0);
      if (D.19727 != 0) goto <D.19728>; else goto <D.19729>;
      <D.19728>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 674, "offset != INVALID_OFFSET");
      <D.19729>:
      D.19730 = ptr + 12;
      named_entries = mono_read16 (D.19730);
      D.19731 = ptr + 14;
      id_entries = mono_read16 (D.19731);
      D.19732 = (int) named_entries;
      D.19733 = (int) id_entries;
      D.19734 = D.19732 + D.19733;
      D.19735 = D.19734 + 2;
      D.19736 = D.19735 * 8;
      D.19737 = (unsigned int) D.19736;
      D.19715 = it.size;
      if (D.19737 > D.19715) goto <D.19738>; else goto <D.19739>;
      <D.19738>:
      D.19718 = ctx->report_error;
      if (D.19718 != 0) goto <D.19740>; else goto <D.19741>;
      <D.19740>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19732 = (int) named_entries;
        D.19733 = (int) id_entries;
        D.19734 = D.19732 + D.19733;
        D.19715 = it.size;
        D.19742 = monoeg_g_strdup_printf ("Resource section is too small, the number of entries (%d) doesn\'t fit on it\'s size %d", D.19734, D.19715);
        vinfo->info.message = D.19742;
        vinfo->exception_type = 3;
        D.19722 = ctx->errors;
        D.19743 = monoeg_g_slist_prepend (D.19722, vinfo);
        ctx->errors = D.19743;
      }
      <D.19741>:
      ctx->valid = 0;
      return;
      <D.19739>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


cleanup_context (struct VerifyContext * ctx, struct GSList * * error_list)
{
  struct SectionHeader * D.19747;
  struct GSList * D.19750;
  gboolean D.19752;

  D.19747 = ctx->sections;
  monoeg_g_free (D.19747);
  if (error_list != 0B) goto <D.19748>; else goto <D.19749>;
  <D.19748>:
  D.19750 = ctx->errors;
  *error_list = D.19750;
  goto <D.19751>;
  <D.19749>:
  D.19750 = ctx->errors;
  mono_free_verify_list (D.19750);
  <D.19751>:
  D.19752 = ctx->valid;
  return D.19752;
}


mono_verifier_verify_cli_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.19754;
  gboolean D.19757;
  _Bool D.19758;
  int D.19759;
  int D.19760;
  struct VerifyContext ctx;
  void cleanup = <<< error >>>;

  try
    {
      D.19754 = mono_verifier_is_enabled_for_image (image);
      if (D.19754 == 0) goto <D.19755>; else goto <D.19756>;
      <D.19755>:
      D.19757 = 1;
      return D.19757;
      <D.19756>:
      D.19758 = error_list != 0B;
      D.19759 = (int) D.19758;
      init_verify_context (&ctx, image, D.19759);
      ctx.stage = 1;
      verify_cli_header (&ctx);
      D.19760 = ctx.valid;
      if (D.19760 == 0) goto cleanup; else goto <D.19761>;
      <D.19761>:
      verify_metadata_header (&ctx);
      D.19760 = ctx.valid;
      if (D.19760 == 0) goto cleanup; else goto <D.19762>;
      <D.19762>:
      verify_tables_schema (&ctx);
      cleanup:
      D.19757 = cleanup_context (&ctx, error_list);
      return D.19757;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


verify_cli_header (struct VerifyContext * ctx)
{
  unsigned int D.19765;
  int D.19768;
  gchar * D.19771;
  struct GSList * D.19772;
  struct GSList * D.19773;
  unsigned int D.19774;
  gchar * D.19779;
  struct GSList * D.19780;
  const char * D.19781;
  _Bool D.19782;
  long int D.19783;
  long int D.19784;
  short unsigned int D.19787;
  short unsigned int D.19792;
  int D.19793;
  gchar * D.19794;
  struct GSList * D.19795;
  const unsigned char * D.19796;
  unsigned int D.19797;
  const unsigned char * D.19798;
  unsigned int D.19799;
  int D.19800;
  unsigned int D.19805;
  unsigned int D.19806;
  gchar * D.19807;
  struct GSList * D.19808;
  unsigned int D.19811;
  unsigned int D.19813;
  gchar * D.19816;
  struct GSList * D.19817;
  const unsigned char * D.19818;
  unsigned int D.19819;
  unsigned int D.19820;
  gchar * D.19825;
  struct GSList * D.19826;
  const unsigned char * D.19827;
  int D.19830;
  gchar * D.19835;
  struct GSList * D.19836;
  gchar * D.19843;
  struct GSList * D.19844;
  struct DataDirectory it;
  guint32 offset;
  const char * ptr;
  int i;

  try
    {
      it = get_data_dir (ctx, 14); [return slot optimization]
      D.19765 = it.rva;
      if (D.19765 == 0) goto <D.19766>; else goto <D.19767>;
      <D.19766>:
      D.19768 = ctx->report_error;
      if (D.19768 != 0) goto <D.19769>; else goto <D.19770>;
      <D.19769>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19771 = monoeg_g_strdup_printf ("CLI header missing");
        vinfo->info.message = D.19771;
        vinfo->exception_type = 3;
        D.19772 = ctx->errors;
        D.19773 = monoeg_g_slist_prepend (D.19772, vinfo);
        ctx->errors = D.19773;
      }
      <D.19770>:
      ctx->valid = 0;
      return;
      <D.19767>:
      D.19774 = it.size;
      if (D.19774 != 72) goto <D.19775>; else goto <D.19776>;
      <D.19775>:
      D.19768 = ctx->report_error;
      if (D.19768 != 0) goto <D.19777>; else goto <D.19778>;
      <D.19777>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19774 = it.size;
        D.19779 = monoeg_g_strdup_printf ("Invalid cli header size in data directory %d must be 72", D.19774);
        vinfo->info.message = D.19779;
        vinfo->exception_type = 3;
        D.19772 = ctx->errors;
        D.19780 = monoeg_g_slist_prepend (D.19772, vinfo);
        ctx->errors = D.19780;
      }
      <D.19778>:
      ctx->valid = 0;
      return;
      <D.19776>:
      offset = it.translated_offset;
      D.19781 = ctx->data;
      ptr = D.19781 + offset;
      D.19782 = offset == 4294967295;
      D.19783 = (long int) D.19782;
      D.19784 = __builtin_expect (D.19783, 0);
      if (D.19784 != 0) goto <D.19785>; else goto <D.19786>;
      <D.19785>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 721, "offset != INVALID_OFFSET");
      <D.19786>:
      D.19787 = mono_read16 (ptr);
      if (D.19787 != 72) goto <D.19788>; else goto <D.19789>;
      <D.19788>:
      D.19768 = ctx->report_error;
      if (D.19768 != 0) goto <D.19790>; else goto <D.19791>;
      <D.19790>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19792 = mono_read16 (ptr);
        D.19793 = (int) D.19792;
        D.19794 = monoeg_g_strdup_printf ("Invalid cli header size %d must be 72", D.19793);
        vinfo->info.message = D.19794;
        vinfo->exception_type = 3;
        D.19772 = ctx->errors;
        D.19795 = monoeg_g_slist_prepend (D.19772, vinfo);
        ctx->errors = D.19795;
      }
      <D.19791>:
      ctx->valid = 0;
      return;
      <D.19789>:
      D.19796 = ptr + 8;
      D.19797 = mono_read32 (D.19796);
      D.19798 = ptr + 12;
      D.19799 = mono_read32 (D.19798);
      D.19800 = bounds_check_virtual_address (ctx, D.19797, D.19799);
      if (D.19800 == 0) goto <D.19801>; else goto <D.19802>;
      <D.19801>:
      D.19768 = ctx->report_error;
      if (D.19768 != 0) goto <D.19803>; else goto <D.19804>;
      <D.19803>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19796 = ptr + 8;
        D.19805 = mono_read32 (D.19796);
        D.19798 = ptr + 12;
        D.19806 = mono_read32 (D.19798);
        D.19807 = monoeg_g_strdup_printf ("Invalid medatata section rva/size pair %x/%x", D.19805, D.19806);
        vinfo->info.message = D.19807;
        vinfo->exception_type = 3;
        D.19772 = ctx->errors;
        D.19808 = monoeg_g_slist_prepend (D.19772, vinfo);
        ctx->errors = D.19808;
      }
      <D.19804>:
      ctx->valid = 0;
      return;
      <D.19802>:
      D.19796 = ptr + 8;
      D.19811 = mono_read32 (D.19796);
      if (D.19811 == 0) goto <D.19809>; else goto <D.19812>;
      <D.19812>:
      D.19798 = ptr + 12;
      D.19813 = mono_read32 (D.19798);
      if (D.19813 == 0) goto <D.19809>; else goto <D.19810>;
      <D.19809>:
      D.19768 = ctx->report_error;
      if (D.19768 != 0) goto <D.19814>; else goto <D.19815>;
      <D.19814>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19816 = monoeg_g_strdup_printf ("Missing medatata section in the CLI header");
        vinfo->info.message = D.19816;
        vinfo->exception_type = 3;
        D.19772 = ctx->errors;
        D.19817 = monoeg_g_slist_prepend (D.19772, vinfo);
        ctx->errors = D.19817;
      }
      <D.19815>:
      ctx->valid = 0;
      return;
      <D.19810>:
      D.19818 = ptr + 16;
      D.19819 = mono_read32 (D.19818);
      D.19820 = D.19819 & 4294901748;
      if (D.19820 != 0) goto <D.19821>; else goto <D.19822>;
      <D.19821>:
      D.19768 = ctx->report_error;
      if (D.19768 != 0) goto <D.19823>; else goto <D.19824>;
      <D.19823>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19825 = monoeg_g_strdup_printf ("Invalid CLI header flags");
        vinfo->info.message = D.19825;
        vinfo->exception_type = 3;
        D.19772 = ctx->errors;
        D.19826 = monoeg_g_slist_prepend (D.19772, vinfo);
        ctx->errors = D.19826;
      }
      <D.19824>:
      ctx->valid = 0;
      return;
      <D.19822>:
      ptr = ptr + 24;
      i = 0;
      goto <D.17522>;
      <D.17521>:
      {
        guint32 rva;
        guint32 size;

        rva = mono_read32 (ptr);
        D.19827 = ptr + 4;
        size = mono_read32 (D.19827);
        if (rva != 0) goto <D.19828>; else goto <D.19829>;
        <D.19828>:
        D.19830 = bounds_check_virtual_address (ctx, rva, size);
        if (D.19830 == 0) goto <D.19831>; else goto <D.19832>;
        <D.19831>:
        D.19768 = ctx->report_error;
        if (D.19768 != 0) goto <D.19833>; else goto <D.19834>;
        <D.19833>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.19835 = monoeg_g_strdup_printf ("Invalid cli section %i rva/size pair %x/%x", i, rva, size);
          vinfo->info.message = D.19835;
          vinfo->exception_type = 3;
          D.19772 = ctx->errors;
          D.19836 = monoeg_g_slist_prepend (D.19772, vinfo);
          ctx->errors = D.19836;
        }
        <D.19834>:
        ctx->valid = 0;
        return;
        <D.19832>:
        <D.19829>:
        ptr = ptr + 8;
        if (rva != 0) goto <D.19837>; else goto <D.19838>;
        <D.19837>:
        if (i > 1) goto <D.19839>; else goto <D.19840>;
        <D.19839>:
        D.19768 = ctx->report_error;
        if (D.19768 != 0) goto <D.19841>; else goto <D.19842>;
        <D.19841>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.19843 = monoeg_g_strdup_printf ("Metadata verifier doesn\'t support cli header section %d", i);
          vinfo->info.message = D.19843;
          vinfo->exception_type = 3;
          D.19772 = ctx->errors;
          D.19844 = monoeg_g_slist_prepend (D.19772, vinfo);
          ctx->errors = D.19844;
        }
        <D.19842>:
        ctx->valid = 0;
        return;
        <D.19840>:
        <D.19838>:
      }
      i = i + 1;
      <D.17522>:
      if (i <= 5) goto <D.17521>; else goto <D.17523>;
      <D.17523>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


get_data_dir (struct VerifyContext * ctx, int idx)
{
  struct MonoImage * D.19849;
  unsigned int idx.8;
  unsigned int D.19851;
  unsigned int D.19852;
  unsigned int D.19853;
  unsigned int D.19854;
  unsigned int D.19855;
  struct MonoCLIImageInfo * iinfo;
  struct MonoPEDirEntry * entry;
  struct DataDirectory res;

  try
    {
      D.19849 = ctx->image;
      iinfo = D.19849->image_info;
      entry = &iinfo->cli_header.datadir.pe_export_table;
      idx.8 = (unsigned int) idx;
      D.19851 = idx.8 * 8;
      entry = entry + D.19851;
      D.19852 = entry->rva;
      res.rva = D.19852;
      D.19853 = entry->size;
      res.size = D.19853;
      D.19854 = res.rva;
      D.19855 = translate_rva (ctx, D.19854);
      res.translated_offset = D.19855;
      <retval> = res;
      return <retval>;
    }
  finally
    {
      res = {CLOBBER};
    }
}


verify_metadata_header (struct VerifyContext * ctx)
{
  const char * D.19858;
  _Bool D.19859;
  long int D.19860;
  long int D.19861;
  unsigned int D.19864;
  unsigned int D.19865;
  unsigned int D.19866;
  unsigned int D.19869;
  int D.19872;
  gchar * D.19875;
  struct GSList * D.19876;
  struct GSList * D.19877;
  unsigned int D.19878;
  unsigned int D.19883;
  gchar * D.19884;
  struct GSList * D.19885;
  const unsigned char * D.19886;
  unsigned int D.19887;
  unsigned int D.19888;
  unsigned int D.19889;
  int D.19890;
  unsigned int D.19895;
  unsigned int D.19896;
  unsigned int D.19897;
  gchar * D.19898;
  struct GSList * D.19899;
  const unsigned char * D.19900;
  short unsigned int D.19901;
  gchar * D.19906;
  struct GSList * D.19907;
  int D.19908;
  unsigned int D.19913;
  gchar * D.19914;
  struct GSList * D.19915;
  unsigned int D.19916;
  const unsigned char * D.19917;
  int D.19918;
  gchar * D.19923;
  struct GSList * D.19924;
  unsigned int offset.9;
  int D.19926;
  gchar * D.19931;
  struct GSList * D.19932;
  sizetype string_size.10;
  const char * D.19934;
  char D.19935;
  gchar * D.19941;
  struct GSList * D.19942;
  int D.17558;
  int iftmp.11;
  int D.17554;
  const char[9] * D.19946;
  unsigned char D.19947;
  int D.19948;
  unsigned char D.19949;
  int D.19950;
  const unsigned char * D.19955;
  unsigned char D.19956;
  int D.19957;
  const unsigned char * D.19958;
  unsigned char D.19959;
  int D.19960;
  const unsigned char * D.19965;
  unsigned char D.19966;
  int D.19967;
  const unsigned char * D.19968;
  unsigned char D.19969;
  int D.19970;
  const unsigned char * D.19975;
  unsigned char D.19976;
  int D.19977;
  const unsigned char * D.19978;
  unsigned char D.19979;
  int D.19980;
  int D.17567;
  int iftmp.12;
  int D.17563;
  const char[4] * D.19988;
  unsigned char D.19989;
  int D.19990;
  unsigned char D.19991;
  int D.19992;
  const unsigned char * D.19997;
  unsigned char D.19998;
  int D.19999;
  const unsigned char * D.20000;
  unsigned char D.20001;
  int D.20002;
  const unsigned char * D.20007;
  unsigned char D.20008;
  int D.20009;
  const unsigned char * D.20010;
  unsigned char D.20011;
  int D.20012;
  const unsigned char * D.20017;
  unsigned char D.20018;
  int D.20019;
  const unsigned char * D.20020;
  unsigned char D.20021;
  int D.20022;
  int D.17576;
  int iftmp.13;
  int D.17572;
  const char[6] * D.20030;
  unsigned char D.20031;
  int D.20032;
  unsigned char D.20033;
  int D.20034;
  const unsigned char * D.20039;
  unsigned char D.20040;
  int D.20041;
  const unsigned char * D.20042;
  unsigned char D.20043;
  int D.20044;
  const unsigned char * D.20049;
  unsigned char D.20050;
  int D.20051;
  const unsigned char * D.20052;
  unsigned char D.20053;
  int D.20054;
  const unsigned char * D.20059;
  unsigned char D.20060;
  int D.20061;
  const unsigned char * D.20062;
  unsigned char D.20063;
  int D.20064;
  int D.17585;
  int iftmp.14;
  int D.17581;
  const char[6] * D.20072;
  unsigned char D.20073;
  int D.20074;
  unsigned char D.20075;
  int D.20076;
  const unsigned char * D.20081;
  unsigned char D.20082;
  int D.20083;
  const unsigned char * D.20084;
  unsigned char D.20085;
  int D.20086;
  const unsigned char * D.20091;
  unsigned char D.20092;
  int D.20093;
  const unsigned char * D.20094;
  unsigned char D.20095;
  int D.20096;
  const unsigned char * D.20101;
  unsigned char D.20102;
  int D.20103;
  const unsigned char * D.20104;
  unsigned char D.20105;
  int D.20106;
  int D.17594;
  int iftmp.15;
  int D.17590;
  const char[3] * D.20114;
  unsigned char D.20115;
  int D.20116;
  unsigned char D.20117;
  int D.20118;
  const unsigned char * D.20123;
  unsigned char D.20124;
  int D.20125;
  const unsigned char * D.20126;
  unsigned char D.20127;
  int D.20128;
  const unsigned char * D.20133;
  unsigned char D.20134;
  int D.20135;
  const unsigned char * D.20136;
  unsigned char D.20137;
  int D.20138;
  const unsigned char * D.20143;
  unsigned char D.20144;
  int D.20145;
  const unsigned char * D.20146;
  unsigned char D.20147;
  int D.20148;
  int D.20153;
  gchar * D.20156;
  struct GSList * D.20157;
  unsigned int D.20158;
  gchar * D.20163;
  struct GSList * D.20164;
  unsigned int i.16;
  unsigned int D.20166;
  gchar * D.20171;
  struct GSList * D.20172;
  unsigned int D.20173;
  gchar * D.20178;
  struct GSList * D.20179;
  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.19858 = ctx->data;
      ptr = D.19858 + offset;
      D.19859 = offset == 4294967295;
      D.19860 = (long int) D.19859;
      D.19861 = __builtin_expect (D.19860, 0);
      if (D.19861 != 0) goto <D.19862>; else goto <D.19863>;
      <D.19862>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 769, "offset != INVALID_OFFSET");
      <D.19863>:
      ptr = ptr + 8;
      D.19864 = mono_read32 (ptr);
      it.rva = D.19864;
      ptr = ptr + 4;
      D.19865 = mono_read32 (ptr);
      it.size = D.19865;
      D.19866 = it.rva;
      offset = translate_rva (ctx, D.19866);
      it.translated_offset = offset;
      D.19858 = ctx->data;
      ptr = D.19858 + offset;
      D.19859 = offset == 4294967295;
      D.19860 = (long int) D.19859;
      D.19861 = __builtin_expect (D.19860, 0);
      if (D.19861 != 0) goto <D.19867>; else goto <D.19868>;
      <D.19867>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 779, "offset != INVALID_OFFSET");
      <D.19868>:
      D.19869 = it.size;
      if (D.19869 <= 19) goto <D.19870>; else goto <D.19871>;
      <D.19870>:
      D.19872 = ctx->report_error;
      if (D.19872 != 0) goto <D.19873>; else goto <D.19874>;
      <D.19873>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19869 = it.size;
        D.19875 = monoeg_g_strdup_printf ("Metadata root section is too small %d (at least 20 bytes required for initial decoding)", D.19869);
        vinfo->info.message = D.19875;
        vinfo->exception_type = 3;
        D.19876 = ctx->errors;
        D.19877 = monoeg_g_slist_prepend (D.19876, vinfo);
        ctx->errors = D.19877;
      }
      <D.19874>:
      ctx->valid = 0;
      return;
      <D.19871>:
      D.19878 = mono_read32 (ptr);
      if (D.19878 != 1112167234) goto <D.19879>; else goto <D.19880>;
      <D.19879>:
      D.19872 = ctx->report_error;
      if (D.19872 != 0) goto <D.19881>; else goto <D.19882>;
      <D.19881>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19883 = mono_read32 (ptr);
        D.19884 = monoeg_g_strdup_printf ("Invalid metadata signature, expected 0x424A5342 but got %08x", D.19883);
        vinfo->info.message = D.19884;
        vinfo->exception_type = 3;
        D.19876 = ctx->errors;
        D.19885 = monoeg_g_slist_prepend (D.19876, vinfo);
        ctx->errors = D.19885;
      }
      <D.19882>:
      ctx->valid = 0;
      return;
      <D.19880>:
      D.19886 = ptr + 12;
      D.19887 = mono_read32 (D.19886);
      D.19888 = D.19887 + offset;
      D.19889 = D.19888 + 16;
      offset = pad4 (D.19889);
      D.19890 = bounds_check_datadir (&it, offset, 4);
      if (D.19890 == 0) goto <D.19891>; else goto <D.19892>;
      <D.19891>:
      D.19872 = ctx->report_error;
      if (D.19872 != 0) goto <D.19893>; else goto <D.19894>;
      <D.19893>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19869 = it.size;
        D.19895 = it.translated_offset;
        D.19896 = offset - D.19895;
        D.19897 = D.19896 + 4;
        D.19898 = monoeg_g_strdup_printf ("Metadata root section is too small %d (at least %d bytes required for flags decoding)", D.19869, D.19897);
        vinfo->info.message = D.19898;
        vinfo->exception_type = 3;
        D.19876 = ctx->errors;
        D.19899 = monoeg_g_slist_prepend (D.19876, vinfo);
        ctx->errors = D.19899;
      }
      <D.19894>:
      ctx->valid = 0;
      return;
      <D.19892>:
      D.19858 = ctx->data;
      ptr = D.19858 + offset;
      D.19900 = ptr + 2;
      D.19901 = mono_read16 (D.19900);
      section_count = (guint32) D.19901;
      if (section_count <= 1) goto <D.19902>; else goto <D.19903>;
      <D.19902>:
      D.19872 = ctx->report_error;
      if (D.19872 != 0) goto <D.19904>; else goto <D.19905>;
      <D.19904>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.19906 = monoeg_g_strdup_printf ("Metadata root section must have at least 2 streams (#~ and #GUID)");
        vinfo->info.message = D.19906;
        vinfo->exception_type = 3;
        D.19876 = ctx->errors;
        D.19907 = monoeg_g_slist_prepend (D.19876, vinfo);
        ctx->errors = D.19907;
      }
      <D.19905>:
      ctx->valid = 0;
      return;
      <D.19903>:
      ptr = ptr + 4;
      offset = offset + 4;
      i = 0;
      goto <D.17599>;
      <D.17598>:
      {
        guint32 stream_off;
        guint32 stream_size;
        int string_size;
        int stream_idx;

        D.19908 = bounds_check_datadir (&it, offset, 8);
        if (D.19908 == 0) goto <D.19909>; else goto <D.19910>;
        <D.19909>:
        D.19872 = ctx->report_error;
        if (D.19872 != 0) goto <D.19911>; else goto <D.19912>;
        <D.19911>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.19895 = it.translated_offset;
          D.19896 = offset - D.19895;
          D.19913 = D.19896 + 9;
          D.19914 = monoeg_g_strdup_printf ("Metadata root section is too small for initial decode of stream header %d, missing %d bytes", i, D.19913);
          vinfo->info.message = D.19914;
          vinfo->exception_type = 3;
          D.19876 = ctx->errors;
          D.19915 = monoeg_g_slist_prepend (D.19876, vinfo);
          ctx->errors = D.19915;
        }
        <D.19912>:
        ctx->valid = 0;
        return;
        <D.19910>:
        D.19895 = it.translated_offset;
        D.19916 = mono_read32 (ptr);
        stream_off = D.19895 + D.19916;
        D.19917 = ptr + 4;
        stream_size = mono_read32 (D.19917);
        D.19918 = bounds_check_datadir (&it, stream_off, stream_size);
        if (D.19918 == 0) goto <D.19919>; else goto <D.19920>;
        <D.19919>:
        D.19872 = ctx->report_error;
        if (D.19872 != 0) goto <D.19921>; else goto <D.19922>;
        <D.19921>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.19923 = monoeg_g_strdup_printf ("Invalid stream header %d offset/size pair %x/%x", 0, stream_off, stream_size);
          vinfo->info.message = D.19923;
          vinfo->exception_type = 3;
          D.19876 = ctx->errors;
          D.19924 = monoeg_g_slist_prepend (D.19876, vinfo);
          ctx->errors = D.19924;
        }
        <D.19922>:
        ctx->valid = 0;
        return;
        <D.19920>:
        ptr = ptr + 8;
        offset = offset + 8;
        string_size = 0;
        goto <D.17548>;
        <D.17547>:
        offset.9 = offset;
        offset = offset.9 + 1;
        D.19926 = bounds_check_datadir (&it, offset.9, 1);
        if (D.19926 == 0) goto <D.19927>; else goto <D.19928>;
        <D.19927>:
        D.19872 = ctx->report_error;
        if (D.19872 != 0) goto <D.19929>; else goto <D.19930>;
        <D.19929>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.19931 = monoeg_g_strdup_printf ("Metadata root section is too small to decode stream header %d name", i);
          vinfo->info.message = D.19931;
          vinfo->exception_type = 3;
          D.19876 = ctx->errors;
          D.19932 = monoeg_g_slist_prepend (D.19876, vinfo);
          ctx->errors = D.19932;
        }
        <D.19930>:
        ctx->valid = 0;
        return;
        <D.19928>:
        string_size.10 = (sizetype) string_size;
        D.19934 = ptr + string_size.10;
        D.19935 = *D.19934;
        if (D.19935 == 0) goto <D.17546>; else goto <D.19936>;
        <D.19936>:
        string_size = string_size + 1;
        <D.17548>:
        if (string_size <= 31) goto <D.17547>; else goto <D.17546>;
        <D.17546>:
        string_size.10 = (sizetype) string_size;
        D.19934 = ptr + string_size.10;
        D.19935 = *D.19934;
        if (D.19935 != 0) goto <D.19937>; else goto <D.19938>;
        <D.19937>:
        D.19872 = ctx->report_error;
        if (D.19872 != 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 stream header %d name larger than 32 bytes", i);
          vinfo->info.message = D.19941;
          vinfo->exception_type = 3;
          D.19876 = ctx->errors;
          D.19942 = monoeg_g_slist_prepend (D.19876, vinfo);
          ctx->errors = D.19942;
        }
        <D.19940>:
        ctx->valid = 0;
        return;
        <D.19938>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = ptr;
            D.19946 = "#Strings";
            D.19947 = MEM[(const unsigned char *)D.19946];
            D.19948 = (int) D.19947;
            D.19949 = *__s2;
            D.19950 = (int) D.19949;
            __result = D.19948 - D.19950;
            {
              if (__s1_len != 0) goto <D.19951>; else goto <D.19952>;
              <D.19951>:
              if (__result == 0) goto <D.19953>; else goto <D.19954>;
              <D.19953>:
              D.19955 = &MEM[(void *)"#Strings" + 1B];
              D.19956 = *D.19955;
              D.19957 = (int) D.19956;
              D.19958 = __s2 + 1;
              D.19959 = *D.19958;
              D.19960 = (int) D.19959;
              __result = D.19957 - D.19960;
              if (__s1_len > 1) goto <D.19961>; else goto <D.19962>;
              <D.19961>:
              if (__result == 0) goto <D.19963>; else goto <D.19964>;
              <D.19963>:
              D.19965 = &MEM[(void *)"#Strings" + 2B];
              D.19966 = *D.19965;
              D.19967 = (int) D.19966;
              D.19968 = __s2 + 2;
              D.19969 = *D.19968;
              D.19970 = (int) D.19969;
              __result = D.19967 - D.19970;
              if (__s1_len > 2) goto <D.19971>; else goto <D.19972>;
              <D.19971>:
              if (__result == 0) goto <D.19973>; else goto <D.19974>;
              <D.19973>:
              D.19975 = &MEM[(void *)"#Strings" + 3B];
              D.19976 = *D.19975;
              D.19977 = (int) D.19976;
              D.19978 = __s2 + 3;
              D.19979 = *D.19978;
              D.19980 = (int) D.19979;
              __result = D.19977 - D.19980;
              <D.19974>:
              <D.19972>:
              <D.19964>:
              <D.19962>:
              <D.19954>:
              <D.19952>:
            }
            D.17554 = __result;
          }
          iftmp.11 = D.17554;
          goto <D.19981>;
          <D.19945>:
          iftmp.11 = __builtin_strcmp ("#Strings", ptr);
          <D.19981>:
          D.17558 = iftmp.11;
        }
        if (D.17558 == 0) goto <D.19982>; else goto <D.19983>;
        <D.19982>:
        stream_idx = 0;
        goto <D.19984>;
        <D.19983>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = ptr;
            D.19988 = "#US";
            D.19989 = MEM[(const unsigned char *)D.19988];
            D.19990 = (int) D.19989;
            D.19991 = *__s2;
            D.19992 = (int) D.19991;
            __result = D.19990 - D.19992;
            {
              if (__s1_len != 0) goto <D.19993>; else goto <D.19994>;
              <D.19993>:
              if (__result == 0) goto <D.19995>; else goto <D.19996>;
              <D.19995>:
              D.19997 = &MEM[(void *)"#US" + 1B];
              D.19998 = *D.19997;
              D.19999 = (int) D.19998;
              D.20000 = __s2 + 1;
              D.20001 = *D.20000;
              D.20002 = (int) D.20001;
              __result = D.19999 - D.20002;
              if (__s1_len > 1) goto <D.20003>; else goto <D.20004>;
              <D.20003>:
              if (__result == 0) goto <D.20005>; else goto <D.20006>;
              <D.20005>:
              D.20007 = &MEM[(void *)"#US" + 2B];
              D.20008 = *D.20007;
              D.20009 = (int) D.20008;
              D.20010 = __s2 + 2;
              D.20011 = *D.20010;
              D.20012 = (int) D.20011;
              __result = D.20009 - D.20012;
              if (__s1_len > 2) goto <D.20013>; else goto <D.20014>;
              <D.20013>:
              if (__result == 0) goto <D.20015>; else goto <D.20016>;
              <D.20015>:
              D.20017 = &MEM[(void *)"#US" + 3B];
              D.20018 = *D.20017;
              D.20019 = (int) D.20018;
              D.20020 = __s2 + 3;
              D.20021 = *D.20020;
              D.20022 = (int) D.20021;
              __result = D.20019 - D.20022;
              <D.20016>:
              <D.20014>:
              <D.20006>:
              <D.20004>:
              <D.19996>:
              <D.19994>:
            }
            D.17563 = __result;
          }
          iftmp.12 = D.17563;
          goto <D.20023>;
          <D.19987>:
          iftmp.12 = __builtin_strcmp ("#US", ptr);
          <D.20023>:
          D.17567 = iftmp.12;
        }
        if (D.17567 == 0) goto <D.20024>; else goto <D.20025>;
        <D.20024>:
        stream_idx = 1;
        goto <D.20026>;
        <D.20025>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = ptr;
            D.20030 = "#Blob";
            D.20031 = MEM[(const unsigned char *)D.20030];
            D.20032 = (int) D.20031;
            D.20033 = *__s2;
            D.20034 = (int) D.20033;
            __result = D.20032 - D.20034;
            {
              if (__s1_len != 0) goto <D.20035>; else goto <D.20036>;
              <D.20035>:
              if (__result == 0) goto <D.20037>; else goto <D.20038>;
              <D.20037>:
              D.20039 = &MEM[(void *)"#Blob" + 1B];
              D.20040 = *D.20039;
              D.20041 = (int) D.20040;
              D.20042 = __s2 + 1;
              D.20043 = *D.20042;
              D.20044 = (int) D.20043;
              __result = D.20041 - D.20044;
              if (__s1_len > 1) goto <D.20045>; else goto <D.20046>;
              <D.20045>:
              if (__result == 0) goto <D.20047>; else goto <D.20048>;
              <D.20047>:
              D.20049 = &MEM[(void *)"#Blob" + 2B];
              D.20050 = *D.20049;
              D.20051 = (int) D.20050;
              D.20052 = __s2 + 2;
              D.20053 = *D.20052;
              D.20054 = (int) D.20053;
              __result = D.20051 - D.20054;
              if (__s1_len > 2) goto <D.20055>; else goto <D.20056>;
              <D.20055>:
              if (__result == 0) goto <D.20057>; else goto <D.20058>;
              <D.20057>:
              D.20059 = &MEM[(void *)"#Blob" + 3B];
              D.20060 = *D.20059;
              D.20061 = (int) D.20060;
              D.20062 = __s2 + 3;
              D.20063 = *D.20062;
              D.20064 = (int) D.20063;
              __result = D.20061 - D.20064;
              <D.20058>:
              <D.20056>:
              <D.20048>:
              <D.20046>:
              <D.20038>:
              <D.20036>:
            }
            D.17572 = __result;
          }
          iftmp.13 = D.17572;
          goto <D.20065>;
          <D.20029>:
          iftmp.13 = __builtin_strcmp ("#Blob", ptr);
          <D.20065>:
          D.17576 = iftmp.13;
        }
        if (D.17576 == 0) goto <D.20066>; else goto <D.20067>;
        <D.20066>:
        stream_idx = 2;
        goto <D.20068>;
        <D.20067>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = ptr;
            D.20072 = "#GUID";
            D.20073 = MEM[(const unsigned char *)D.20072];
            D.20074 = (int) D.20073;
            D.20075 = *__s2;
            D.20076 = (int) D.20075;
            __result = D.20074 - D.20076;
            {
              if (__s1_len != 0) goto <D.20077>; else goto <D.20078>;
              <D.20077>:
              if (__result == 0) goto <D.20079>; else goto <D.20080>;
              <D.20079>:
              D.20081 = &MEM[(void *)"#GUID" + 1B];
              D.20082 = *D.20081;
              D.20083 = (int) D.20082;
              D.20084 = __s2 + 1;
              D.20085 = *D.20084;
              D.20086 = (int) D.20085;
              __result = D.20083 - D.20086;
              if (__s1_len > 1) goto <D.20087>; else goto <D.20088>;
              <D.20087>:
              if (__result == 0) goto <D.20089>; else goto <D.20090>;
              <D.20089>:
              D.20091 = &MEM[(void *)"#GUID" + 2B];
              D.20092 = *D.20091;
              D.20093 = (int) D.20092;
              D.20094 = __s2 + 2;
              D.20095 = *D.20094;
              D.20096 = (int) D.20095;
              __result = D.20093 - D.20096;
              if (__s1_len > 2) goto <D.20097>; else goto <D.20098>;
              <D.20097>:
              if (__result == 0) goto <D.20099>; else goto <D.20100>;
              <D.20099>:
              D.20101 = &MEM[(void *)"#GUID" + 3B];
              D.20102 = *D.20101;
              D.20103 = (int) D.20102;
              D.20104 = __s2 + 3;
              D.20105 = *D.20104;
              D.20106 = (int) D.20105;
              __result = D.20103 - D.20106;
              <D.20100>:
              <D.20098>:
              <D.20090>:
              <D.20088>:
              <D.20080>:
              <D.20078>:
            }
            D.17581 = __result;
          }
          iftmp.14 = D.17581;
          goto <D.20107>;
          <D.20071>:
          iftmp.14 = __builtin_strcmp ("#GUID", ptr);
          <D.20107>:
          D.17585 = iftmp.14;
        }
        if (D.17585 == 0) goto <D.20108>; else goto <D.20109>;
        <D.20108>:
        stream_idx = 3;
        goto <D.20110>;
        <D.20109>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = ptr;
            D.20114 = "#~";
            D.20115 = MEM[(const unsigned char *)D.20114];
            D.20116 = (int) D.20115;
            D.20117 = *__s2;
            D.20118 = (int) D.20117;
            __result = D.20116 - D.20118;
            {
              if (__s1_len != 0) goto <D.20119>; else goto <D.20120>;
              <D.20119>:
              if (__result == 0) goto <D.20121>; else goto <D.20122>;
              <D.20121>:
              D.20123 = &MEM[(void *)"#~" + 1B];
              D.20124 = *D.20123;
              D.20125 = (int) D.20124;
              D.20126 = __s2 + 1;
              D.20127 = *D.20126;
              D.20128 = (int) D.20127;
              __result = D.20125 - D.20128;
              if (__s1_len > 1) goto <D.20129>; else goto <D.20130>;
              <D.20129>:
              if (__result == 0) goto <D.20131>; else goto <D.20132>;
              <D.20131>:
              D.20133 = &MEM[(void *)"#~" + 2B];
              D.20134 = *D.20133;
              D.20135 = (int) D.20134;
              D.20136 = __s2 + 2;
              D.20137 = *D.20136;
              D.20138 = (int) D.20137;
              __result = D.20135 - D.20138;
              if (__s1_len > 2) goto <D.20139>; else goto <D.20140>;
              <D.20139>:
              if (__result == 0) goto <D.20141>; else goto <D.20142>;
              <D.20141>:
              D.20143 = &MEM[(void *)"#~" + 3B];
              D.20144 = *D.20143;
              D.20145 = (int) D.20144;
              D.20146 = __s2 + 3;
              D.20147 = *D.20146;
              D.20148 = (int) D.20147;
              __result = D.20145 - D.20148;
              <D.20142>:
              <D.20140>:
              <D.20132>:
              <D.20130>:
              <D.20122>:
              <D.20120>:
            }
            D.17590 = __result;
          }
          iftmp.15 = D.17590;
          goto <D.20149>;
          <D.20113>:
          iftmp.15 = __builtin_strcmp ("#~", ptr);
          <D.20149>:
          D.17594 = iftmp.15;
        }
        if (D.17594 == 0) goto <D.20150>; else goto <D.20151>;
        <D.20150>:
        stream_idx = 4;
        goto <D.20152>;
        <D.20151>:
        D.20153 = ctx->report_warning;
        if (D.20153 != 0) goto <D.20154>; else goto <D.20155>;
        <D.20154>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 2;
          D.20156 = monoeg_g_strdup_printf ("Metadata stream header %d invalid name %s", i, ptr);
          vinfo->info.message = D.20156;
          vinfo->exception_type = 3;
          D.19876 = ctx->errors;
          D.20157 = monoeg_g_slist_prepend (D.19876, vinfo);
          ctx->errors = D.20157;
        }
        ctx->valid = 0;
        return;
        <D.20155>:
        offset = pad4 (offset);
        D.19858 = ctx->data;
        ptr = D.19858 + offset;
        // predicted unlikely by continue predictor.
        goto <D.17596>;
        <D.20152>:
        <D.20110>:
        <D.20068>:
        <D.20026>:
        <D.19984>:
        D.20158 = ctx->metadata_streams[stream_idx].offset;
        if (D.20158 != 0) goto <D.20159>; else goto <D.20160>;
        <D.20159>:
        D.19872 = ctx->report_error;
        if (D.19872 != 0) goto <D.20161>; else goto <D.20162>;
        <D.20161>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.20163 = monoeg_g_strdup_printf ("Duplicated metadata stream header %s", ptr);
          vinfo->info.message = D.20163;
          vinfo->exception_type = 3;
          D.19876 = ctx->errors;
          D.20164 = monoeg_g_slist_prepend (D.19876, vinfo);
          ctx->errors = D.20164;
        }
        <D.20162>:
        ctx->valid = 0;
        return;
        <D.20160>:
        ctx->metadata_streams[stream_idx].offset = stream_off;
        ctx->metadata_streams[stream_idx].size = stream_size;
        offset = pad4 (offset);
        D.19858 = ctx->data;
        ptr = D.19858 + offset;
      }
      <D.17596>:
      i = i + 1;
      <D.17599>:
      i.16 = (unsigned int) i;
      if (i.16 < section_count) goto <D.17598>; else goto <D.17600>;
      <D.17600>:
      D.20166 = ctx->metadata_streams[4].size;
      if (D.20166 == 0) goto <D.20167>; else goto <D.20168>;
      <D.20167>:
      D.19872 = ctx->report_error;
      if (D.19872 != 0) goto <D.20169>; else goto <D.20170>;
      <D.20169>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20171 = monoeg_g_strdup_printf ("Metadata #~ stream missing");
        vinfo->info.message = D.20171;
        vinfo->exception_type = 3;
        D.19876 = ctx->errors;
        D.20172 = monoeg_g_slist_prepend (D.19876, vinfo);
        ctx->errors = D.20172;
      }
      <D.20170>:
      ctx->valid = 0;
      return;
      <D.20168>:
      D.20173 = ctx->metadata_streams[3].size;
      if (D.20173 == 0) goto <D.20174>; else goto <D.20175>;
      <D.20174>:
      D.19872 = ctx->report_error;
      if (D.19872 != 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 ("Metadata guid stream missing");
        vinfo->info.message = D.20178;
        vinfo->exception_type = 3;
        D.19876 = ctx->errors;
        D.20179 = monoeg_g_slist_prepend (D.19876, vinfo);
        ctx->errors = D.20179;
      }
      <D.20177>:
      ctx->valid = 0;
      return;
      <D.20175>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


bounds_check_datadir (struct DataDirectory * dir, guint32 offset, guint32 size)
{
  unsigned int D.20183;
  gboolean D.20186;
  unsigned int D.20187;
  unsigned int D.20190;
  unsigned int D.20191;
  _Bool D.20192;

  D.20183 = dir->translated_offset;
  if (D.20183 > offset) goto <D.20184>; else goto <D.20185>;
  <D.20184>:
  D.20186 = 0;
  return D.20186;
  <D.20185>:
  D.20187 = dir->size;
  if (D.20187 < size) goto <D.20188>; else goto <D.20189>;
  <D.20188>:
  D.20186 = 0;
  return D.20186;
  <D.20189>:
  D.20190 = offset + size;
  D.20183 = dir->translated_offset;
  D.20187 = dir->size;
  D.20191 = D.20183 + D.20187;
  D.20192 = D.20190 <= D.20191;
  D.20186 = (gboolean) D.20192;
  return D.20186;
}


pad4 (guint32 offset)
{
  unsigned int D.20194;
  unsigned int D.20197;
  guint32 D.20198;

  D.20194 = offset & 3;
  if (D.20194 != 0) goto <D.20195>; else goto <D.20196>;
  <D.20195>:
  D.20197 = offset & 4294967292;
  offset = D.20197 + 4;
  <D.20196>:
  D.20198 = offset;
  return D.20198;
}


verify_tables_schema (struct VerifyContext * ctx)
{
  const char * D.20200;
  unsigned int D.20201;
  int D.20204;
  gchar * D.20207;
  struct GSList * D.20208;
  struct GSList * D.20209;
  const char * D.20210;
  char D.20211;
  unsigned char D.20212;
  unsigned char D.20213;
  int D.20218;
  gchar * D.20219;
  struct GSList * D.20220;
  const char * D.20221;
  char D.20222;
  int D.20227;
  gchar * D.20228;
  struct GSList * D.20229;
  const char * D.20230;
  char D.20231;
  signed char D.20232;
  unsigned char * D.20237;
  unsigned char D.20238;
  int D.20239;
  gchar * D.20240;
  struct GSList * D.20241;
  const unsigned char * D.20242;
  long long unsigned int D.20243;
  long long unsigned int D.20244;
  gchar * D.20255;
  struct GSList * D.20256;
  unsigned int i.17;
  unsigned int D.20260;
  gchar * D.20264;
  struct GSList * D.20265;
  unsigned int D.20266;
  unsigned int D.20267;
  gchar * D.20272;
  struct GSList * D.20273;
  gchar * D.20280;
  struct GSList * D.20281;
  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.20200 = ctx->data;
      ptr = D.20200 + offset;
      D.20201 = tables_area.size;
      if (D.20201 <= 23) goto <D.20202>; else goto <D.20203>;
      <D.20202>:
      D.20204 = ctx->report_error;
      if (D.20204 != 0) goto <D.20205>; else goto <D.20206>;
      <D.20205>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20201 = tables_area.size;
        D.20207 = monoeg_g_strdup_printf ("Table schemata size (%d) too small to for initial decoding (requires 24 bytes)", D.20201);
        vinfo->info.message = D.20207;
        vinfo->exception_type = 3;
        D.20208 = ctx->errors;
        D.20209 = monoeg_g_slist_prepend (D.20208, vinfo);
        ctx->errors = D.20209;
      }
      <D.20206>:
      ctx->valid = 0;
      return;
      <D.20203>:
      D.20210 = ptr + 4;
      D.20211 = *D.20210;
      D.20212 = (unsigned char) D.20211;
      D.20213 = D.20212 + 255;
      if (D.20213 > 1) goto <D.20214>; else goto <D.20215>;
      <D.20214>:
      D.20204 = ctx->report_error;
      if (D.20204 != 0) goto <D.20216>; else goto <D.20217>;
      <D.20216>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20210 = ptr + 4;
        D.20211 = *D.20210;
        D.20218 = (int) D.20211;
        D.20219 = monoeg_g_strdup_printf ("Invalid table schemata major version %d, expected 2", D.20218);
        vinfo->info.message = D.20219;
        vinfo->exception_type = 3;
        D.20208 = ctx->errors;
        D.20220 = monoeg_g_slist_prepend (D.20208, vinfo);
        ctx->errors = D.20220;
      }
      <D.20217>:
      ctx->valid = 0;
      return;
      <D.20215>:
      D.20221 = ptr + 5;
      D.20222 = *D.20221;
      if (D.20222 != 0) goto <D.20223>; else goto <D.20224>;
      <D.20223>:
      D.20204 = ctx->report_error;
      if (D.20204 != 0) goto <D.20225>; else goto <D.20226>;
      <D.20225>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20221 = ptr + 5;
        D.20222 = *D.20221;
        D.20227 = (int) D.20222;
        D.20228 = monoeg_g_strdup_printf ("Invalid table schemata minor version %d, expected 0", D.20227);
        vinfo->info.message = D.20228;
        vinfo->exception_type = 3;
        D.20208 = ctx->errors;
        D.20229 = monoeg_g_slist_prepend (D.20208, vinfo);
        ctx->errors = D.20229;
      }
      <D.20226>:
      ctx->valid = 0;
      return;
      <D.20224>:
      D.20230 = ptr + 6;
      D.20231 = *D.20230;
      D.20232 = D.20231 & -8;
      if (D.20232 != 0) goto <D.20233>; else goto <D.20234>;
      <D.20233>:
      D.20204 = ctx->report_error;
      if (D.20204 != 0) goto <D.20235>; else goto <D.20236>;
      <D.20235>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20237 = ptr + 6;
        D.20238 = *D.20237;
        D.20239 = (int) D.20238;
        D.20240 = monoeg_g_strdup_printf ("Invalid table schemata heap sizes 0x%02x, only bits 0, 1 and 2 can be set", D.20239);
        vinfo->info.message = D.20240;
        vinfo->exception_type = 3;
        D.20208 = ctx->errors;
        D.20241 = monoeg_g_slist_prepend (D.20208, vinfo);
        ctx->errors = D.20241;
      }
      <D.20236>:
      ctx->valid = 0;
      return;
      <D.20234>:
      D.20242 = ptr + 8;
      valid_tables = mono_read64 (D.20242);
      count = 0;
      i = 0;
      goto <D.17620>;
      <D.17619>:
      D.20243 = valid_tables >> i;
      D.20244 = D.20243 & 1;
      if (D.20244 == 0) goto <D.20245>; else goto <D.20246>;
      <D.20245>:
      // predicted unlikely by continue predictor.
      goto <D.17616>;
      <D.20246>:
      if (i == 3) goto <D.20247>; else goto <D.20249>;
      <D.20249>:
      if (i == 5) goto <D.20247>; else goto <D.20250>;
      <D.20250>:
      if (i == 7) goto <D.20247>; else goto <D.20251>;
      <D.20251>:
      if (i == 19) goto <D.20247>; else goto <D.20252>;
      <D.20252>:
      if (i == 22) goto <D.20247>; else goto <D.20248>;
      <D.20247>:
      D.20204 = ctx->report_error;
      if (D.20204 != 0) goto <D.20253>; else goto <D.20254>;
      <D.20253>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20255 = monoeg_g_strdup_printf ("The metadata verifier doesn\'t support MS specific table %x", i);
        vinfo->info.message = D.20255;
        vinfo->exception_type = 3;
        D.20208 = ctx->errors;
        D.20256 = monoeg_g_slist_prepend (D.20208, vinfo);
        ctx->errors = D.20256;
      }
      <D.20254>:
      ctx->valid = 0;
      return;
      <D.20248>:
      i.17 = (unsigned int) i;
      D.20260 = i.17 + 4294967266;
      if (D.20260 <= 1) goto <D.20257>; else goto <D.20261>;
      <D.20261>:
      if (i > 44) goto <D.20257>; else goto <D.20258>;
      <D.20257>:
      D.20204 = ctx->report_error;
      if (D.20204 != 0) goto <D.20262>; else goto <D.20263>;
      <D.20262>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20264 = monoeg_g_strdup_printf ("Invalid table %x", i);
        vinfo->info.message = D.20264;
        vinfo->exception_type = 3;
        D.20208 = ctx->errors;
        D.20265 = monoeg_g_slist_prepend (D.20208, vinfo);
        ctx->errors = D.20265;
      }
      <D.20263>:
      ctx->valid = 0;
      return;
      <D.20258>:
      count = count + 1;
      <D.17616>:
      i = i + 1;
      <D.17620>:
      if (i <= 63) goto <D.17619>; else goto <D.17621>;
      <D.17621>:
      D.20201 = tables_area.size;
      D.20266 = count + 6;
      D.20267 = D.20266 * 4;
      if (D.20201 < D.20267) goto <D.20268>; else goto <D.20269>;
      <D.20268>:
      D.20204 = ctx->report_error;
      if (D.20204 != 0) goto <D.20270>; else goto <D.20271>;
      <D.20270>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20201 = tables_area.size;
        D.20266 = count + 6;
        D.20267 = D.20266 * 4;
        D.20272 = monoeg_g_strdup_printf ("Table schemata size (%d) too small to for decoding row counts (requires %d bytes)", D.20201, D.20267);
        vinfo->info.message = D.20272;
        vinfo->exception_type = 3;
        D.20208 = ctx->errors;
        D.20273 = monoeg_g_slist_prepend (D.20208, vinfo);
        ctx->errors = D.20273;
      }
      <D.20271>:
      ctx->valid = 0;
      return;
      <D.20269>:
      ptr = ptr + 24;
      i = 0;
      goto <D.17626>;
      <D.17625>:
      D.20243 = valid_tables >> i;
      D.20244 = D.20243 & 1;
      if (D.20244 != 0) goto <D.20274>; else goto <D.20275>;
      <D.20274>:
      {
        guint32 row_count;

        row_count = mono_read32 (ptr);
        if (row_count > 16777215) goto <D.20276>; else goto <D.20277>;
        <D.20276>:
        D.20204 = ctx->report_error;
        if (D.20204 != 0) goto <D.20278>; else goto <D.20279>;
        <D.20278>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.20280 = monoeg_g_strdup_printf ("Invalid Table %d row count: %d. Mono only supports 16777215 rows", i, row_count);
          vinfo->info.message = D.20280;
          vinfo->exception_type = 3;
          D.20208 = ctx->errors;
          D.20281 = monoeg_g_slist_prepend (D.20208, vinfo);
          ctx->errors = D.20281;
        }
        <D.20279>:
        ctx->valid = 0;
        return;
        <D.20277>:
        ptr = ptr + 4;
      }
      <D.20275>:
      i = i + 1;
      <D.17626>:
      if (i <= 63) goto <D.17625>; else goto <D.17627>;
      <D.17627>:
    }
  finally
    {
      tables_area = {CLOBBER};
    }
}


mono_verifier_verify_table_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.20285;
  gboolean D.20288;
  _Bool D.20289;
  int D.20290;
  struct VerifyContext ctx;

  try
    {
      D.20285 = mono_verifier_is_enabled_for_image (image);
      if (D.20285 == 0) goto <D.20286>; else goto <D.20287>;
      <D.20286>:
      D.20288 = 1;
      return D.20288;
      <D.20287>:
      D.20289 = error_list != 0B;
      D.20290 = (int) D.20289;
      init_verify_context (&ctx, image, D.20290);
      ctx.stage = 2;
      verify_tables_data (&ctx);
      D.20288 = cleanup_context (&ctx, error_list);
      return D.20288;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


verify_tables_data (struct VerifyContext * ctx)
{
  struct MonoImage * D.20293;
  struct MonoStreamHeader * D.20294;
  unsigned char D.20295;
  unsigned int D.20296;
  <unnamed-unsigned:24> D.20297;
  unsigned int D.20298;
  unsigned int D.20299;
  int D.20304;
  gchar * D.20307;
  struct GSList * D.20308;
  struct GSList * D.20309;
  const char * D.20310;
  int D.20311;
  const char * D.20312;
  int D.20313;
  int D.20314;
  int D.20315;
  unsigned int D.20320;
  unsigned int D.20321;
  unsigned int D.20322;
  unsigned int D.20323;
  gchar * D.20324;
  struct GSList * D.20325;
  int D.20326;
  struct OffsetAndSize tables_area;
  guint32 size;
  guint32 tables_offset;
  int i;

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

        D.20293 = ctx->image;
        table = &D.20293->tables[i];
        D.20295 = table->row_size;
        D.20296 = (unsigned int) D.20295;
        D.20297 = table->rows;
        D.20298 = (unsigned int) D.20297;
        D.20299 = D.20296 * D.20298;
        tmp_size = D.20299 + size;
        if (tmp_size < size) goto <D.20300>; else goto <D.20301>;
        <D.20300>:
        size = 0;
        goto <D.19090>;
        <D.20301>:
        size = tmp_size;
      }
      i = i + 1;
      <D.19092>:
      if (i <= 44) goto <D.19091>; else goto <D.19090>;
      <D.19090>:
      if (size == 0) goto <D.20302>; else goto <D.20303>;
      <D.20302>:
      D.20304 = ctx->report_error;
      if (D.20304 != 0) goto <D.20305>; else goto <D.20306>;
      <D.20305>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20307 = monoeg_g_strdup_printf ("table space is either empty or overflowed");
        vinfo->info.message = D.20307;
        vinfo->exception_type = 3;
        D.20308 = ctx->errors;
        D.20309 = monoeg_g_slist_prepend (D.20308, vinfo);
        ctx->errors = D.20309;
      }
      <D.20306>:
      ctx->valid = 0;
      return;
      <D.20303>:
      D.20293 = ctx->image;
      D.20310 = D.20293->tables_base;
      D.20311 = (int) D.20310;
      D.20312 = ctx->data;
      D.20313 = (int) D.20312;
      D.20314 = D.20311 - D.20313;
      tables_offset = (guint32) D.20314;
      D.20315 = bounds_check_offset (&tables_area, tables_offset, size);
      if (D.20315 == 0) goto <D.20316>; else goto <D.20317>;
      <D.20316>:
      D.20304 = ctx->report_error;
      if (D.20304 != 0) goto <D.20318>; else goto <D.20319>;
      <D.20318>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20320 = tables_area.size;
        D.20321 = tables_area.offset;
        D.20322 = D.20321 - tables_offset;
        D.20323 = D.20320 + D.20322;
        D.20324 = monoeg_g_strdup_printf ("Tables data require %d bytes but the only %d are available in the #~ stream", size, D.20323);
        vinfo->info.message = D.20324;
        vinfo->exception_type = 3;
        D.20308 = ctx->errors;
        D.20325 = monoeg_g_slist_prepend (D.20308, vinfo);
        ctx->errors = D.20325;
      }
      <D.20319>:
      ctx->valid = 0;
      return;
      <D.20317>:
      verify_module_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20327>; else goto <D.20328>;
      <D.20327>:
      return;
      <D.20328>:
      verify_typedef_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20329>; else goto <D.20330>;
      <D.20329>:
      return;
      <D.20330>:
      verify_field_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20331>; else goto <D.20332>;
      <D.20331>:
      return;
      <D.20332>:
      verify_method_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20333>; else goto <D.20334>;
      <D.20333>:
      return;
      <D.20334>:
      verify_param_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20335>; else goto <D.20336>;
      <D.20335>:
      return;
      <D.20336>:
      verify_interfaceimpl_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20337>; else goto <D.20338>;
      <D.20337>:
      return;
      <D.20338>:
      verify_memberref_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20339>; else goto <D.20340>;
      <D.20339>:
      return;
      <D.20340>:
      verify_constant_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20341>; else goto <D.20342>;
      <D.20341>:
      return;
      <D.20342>:
      verify_cattr_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20343>; else goto <D.20344>;
      <D.20343>:
      return;
      <D.20344>:
      verify_field_marshal_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20345>; else goto <D.20346>;
      <D.20345>:
      return;
      <D.20346>:
      verify_decl_security_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20347>; else goto <D.20348>;
      <D.20347>:
      return;
      <D.20348>:
      verify_class_layout_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20349>; else goto <D.20350>;
      <D.20349>:
      return;
      <D.20350>:
      verify_field_layout_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20351>; else goto <D.20352>;
      <D.20351>:
      return;
      <D.20352>:
      verify_standalonesig_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20353>; else goto <D.20354>;
      <D.20353>:
      return;
      <D.20354>:
      verify_eventmap_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20355>; else goto <D.20356>;
      <D.20355>:
      return;
      <D.20356>:
      verify_event_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20357>; else goto <D.20358>;
      <D.20357>:
      return;
      <D.20358>:
      verify_propertymap_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20359>; else goto <D.20360>;
      <D.20359>:
      return;
      <D.20360>:
      verify_property_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20361>; else goto <D.20362>;
      <D.20361>:
      return;
      <D.20362>:
      verify_methodimpl_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20363>; else goto <D.20364>;
      <D.20363>:
      return;
      <D.20364>:
      verify_moduleref_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20365>; else goto <D.20366>;
      <D.20365>:
      return;
      <D.20366>:
      verify_typespec_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20367>; else goto <D.20368>;
      <D.20367>:
      return;
      <D.20368>:
      verify_implmap_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20369>; else goto <D.20370>;
      <D.20369>:
      return;
      <D.20370>:
      verify_fieldrva_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20371>; else goto <D.20372>;
      <D.20371>:
      return;
      <D.20372>:
      verify_assembly_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20373>; else goto <D.20374>;
      <D.20373>:
      return;
      <D.20374>:
      verify_assemblyref_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20375>; else goto <D.20376>;
      <D.20375>:
      return;
      <D.20376>:
      verify_file_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20377>; else goto <D.20378>;
      <D.20377>:
      return;
      <D.20378>:
      verify_exportedtype_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20379>; else goto <D.20380>;
      <D.20379>:
      return;
      <D.20380>:
      verify_manifest_resource_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20381>; else goto <D.20382>;
      <D.20381>:
      return;
      <D.20382>:
      verify_nested_class_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20383>; else goto <D.20384>;
      <D.20383>:
      return;
      <D.20384>:
      verify_generic_param_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20385>; else goto <D.20386>;
      <D.20385>:
      return;
      <D.20386>:
      verify_method_spec_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20387>; else goto <D.20388>;
      <D.20387>:
      return;
      <D.20388>:
      verify_generic_param_constraint_table (ctx);
      D.20326 = ctx->valid;
      if (D.20326 == 0) goto <D.20389>; else goto <D.20390>;
      <D.20389>:
      return;
      <D.20390>:
      verify_tables_data_global_constraints (ctx);
    }
  finally
    {
      tables_area = {CLOBBER};
    }
}


get_metadata_stream (struct VerifyContext * ctx, struct MonoStreamHeader * header)
{
  const char * D.20395;
  int D.20396;
  const char * D.20397;
  int D.20398;
  int D.20399;
  unsigned int D.20400;
  unsigned int D.20401;
  struct OffsetAndSize res;

  try
    {
      D.20395 = header->data;
      D.20396 = (int) D.20395;
      D.20397 = ctx->data;
      D.20398 = (int) D.20397;
      D.20399 = D.20396 - D.20398;
      D.20400 = (unsigned int) D.20399;
      res.offset = D.20400;
      D.20401 = header->size;
      res.size = D.20401;
      <retval> = res;
      return <retval>;
    }
  finally
    {
      res = {CLOBBER};
    }
}


bounds_check_offset (struct OffsetAndSize * off, guint32 offset, guint32 size)
{
  unsigned int D.20404;
  gboolean D.20407;
  unsigned int D.20408;
  unsigned int D.20411;
  unsigned int D.20412;
  _Bool D.20413;

  D.20404 = off->offset;
  if (D.20404 > offset) goto <D.20405>; else goto <D.20406>;
  <D.20405>:
  D.20407 = 0;
  return D.20407;
  <D.20406>:
  D.20408 = off->size;
  if (D.20408 < size) goto <D.20409>; else goto <D.20410>;
  <D.20409>:
  D.20407 = 0;
  return D.20407;
  <D.20410>:
  D.20411 = offset + size;
  D.20404 = off->offset;
  D.20408 = off->size;
  D.20412 = D.20404 + D.20408;
  D.20413 = D.20411 <= D.20412;
  D.20407 = (gboolean) D.20413;
  return D.20407;
}


verify_module_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.20415;
  unsigned int D.20416;
  unsigned int D.20417;
  int D.20420;
  <unnamed-unsigned:24> D.20423;
  int D.20424;
  gchar * D.20425;
  struct GSList * D.20426;
  struct GSList * D.20427;
  unsigned int D.20428;
  int D.20429;
  gchar * D.20434;
  struct GSList * D.20435;
  unsigned int D.20436;
  int D.20437;
  gchar * D.20442;
  struct GSList * D.20443;
  unsigned int D.20444;
  gchar * D.20449;
  struct GSList * D.20450;
  unsigned int D.20451;
  gchar * D.20456;
  struct GSList * D.20457;
  struct MonoTableInfo * table;
  guint32 data[5];

  try
    {
      D.20415 = ctx->image;
      table = &D.20415->tables[0];
      D.20416 = BIT_FIELD_REF <*table, 32, 32>;
      D.20417 = D.20416 & 16777215;
      if (D.20417 != 1) goto <D.20418>; else goto <D.20419>;
      <D.20418>:
      D.20420 = ctx->report_error;
      if (D.20420 != 0) goto <D.20421>; else goto <D.20422>;
      <D.20421>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20423 = table->rows;
        D.20424 = (int) D.20423;
        D.20425 = monoeg_g_strdup_printf ("Module table must have exactly one row, but have %d", D.20424);
        vinfo->info.message = D.20425;
        vinfo->exception_type = 3;
        D.20426 = ctx->errors;
        D.20427 = monoeg_g_slist_prepend (D.20426, vinfo);
        ctx->errors = D.20427;
      }
      <D.20422>:
      ctx->valid = 0;
      return;
      <D.20419>:
      mono_metadata_decode_row (table, 0, &data, 5);
      D.20428 = data[1];
      D.20429 = is_valid_non_empty_string (ctx, D.20428);
      if (D.20429 == 0) goto <D.20430>; else goto <D.20431>;
      <D.20430>:
      D.20420 = ctx->report_error;
      if (D.20420 != 0) goto <D.20432>; else goto <D.20433>;
      <D.20432>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20428 = data[1];
        D.20434 = monoeg_g_strdup_printf ("Module has an invalid name, string index 0x%08x", D.20428);
        vinfo->info.message = D.20434;
        vinfo->exception_type = 3;
        D.20426 = ctx->errors;
        D.20435 = monoeg_g_slist_prepend (D.20426, vinfo);
        ctx->errors = D.20435;
      }
      <D.20433>:
      ctx->valid = 0;
      return;
      <D.20431>:
      D.20436 = data[2];
      D.20437 = is_valid_guid (ctx, D.20436);
      if (D.20437 == 0) goto <D.20438>; else goto <D.20439>;
      <D.20438>:
      D.20420 = ctx->report_error;
      if (D.20420 != 0) goto <D.20440>; else goto <D.20441>;
      <D.20440>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20436 = data[2];
        D.20442 = monoeg_g_strdup_printf ("Module has an invalid Mvid, guid index %x", D.20436);
        vinfo->info.message = D.20442;
        vinfo->exception_type = 3;
        D.20426 = ctx->errors;
        D.20443 = monoeg_g_slist_prepend (D.20426, vinfo);
        ctx->errors = D.20443;
      }
      <D.20441>:
      ctx->valid = 0;
      return;
      <D.20439>:
      D.20444 = data[3];
      if (D.20444 != 0) goto <D.20445>; else goto <D.20446>;
      <D.20445>:
      D.20420 = ctx->report_error;
      if (D.20420 != 0) goto <D.20447>; else goto <D.20448>;
      <D.20447>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20444 = data[3];
        D.20449 = monoeg_g_strdup_printf ("Module has a non zero Enc field %x", D.20444);
        vinfo->info.message = D.20449;
        vinfo->exception_type = 3;
        D.20426 = ctx->errors;
        D.20450 = monoeg_g_slist_prepend (D.20426, vinfo);
        ctx->errors = D.20450;
      }
      <D.20448>:
      ctx->valid = 0;
      return;
      <D.20446>:
      D.20451 = data[4];
      if (D.20451 != 0) goto <D.20452>; else goto <D.20453>;
      <D.20452>:
      D.20420 = ctx->report_error;
      if (D.20420 != 0) goto <D.20454>; else goto <D.20455>;
      <D.20454>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20451 = data[4];
        D.20456 = monoeg_g_strdup_printf ("Module has a non zero EncBase field %x", D.20451);
        vinfo->info.message = D.20456;
        vinfo->exception_type = 3;
        D.20426 = ctx->errors;
        D.20457 = monoeg_g_slist_prepend (D.20426, vinfo);
        ctx->errors = D.20457;
      }
      <D.20455>:
      ctx->valid = 0;
      return;
      <D.20453>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


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

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


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

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


is_valid_string_full_with_image (struct MonoImage * image, guint32 offset, gboolean allow_empty)
{
  const char * D.20466;
  int D.20467;
  char * D.20468;
  int D.20469;
  int D.20470;
  gboolean D.20473;
  unsigned int D.20474;
  unsigned int data.18;
  const gchar * D.20478;
  unsigned int D.20479;
  long int D.20480;
  int D.20481;
  int iftmp.19;
  long int length.20;
  guint32 heap_offset;
  guint32 heap_size;
  glong length;
  const char * data;

  try
    {
      D.20466 = image->heap_strings.data;
      D.20467 = (int) D.20466;
      D.20468 = image->raw_data;
      D.20469 = (int) D.20468;
      D.20470 = D.20467 - D.20469;
      heap_offset = (guint32) D.20470;
      heap_size = image->heap_strings.size;
      D.20468 = image->raw_data;
      data = D.20468 + heap_offset;
      if (offset >= heap_size) goto <D.20471>; else goto <D.20472>;
      <D.20471>:
      D.20473 = 0;
      return D.20473;
      <D.20472>:
      D.20474 = ~offset;
      data.18 = (unsigned int) data;
      if (D.20474 < data.18) goto <D.20476>; else goto <D.20477>;
      <D.20476>:
      D.20473 = 0;
      return D.20473;
      <D.20477>:
      D.20478 = data + offset;
      D.20479 = heap_size - offset;
      D.20480 = (long int) D.20479;
      D.20481 = mono_utf8_validate_and_len_with_bounds (D.20478, D.20480, &length, 0B);
      if (D.20481 == 0) goto <D.20482>; else goto <D.20483>;
      <D.20482>:
      D.20473 = 0;
      return D.20473;
      <D.20483>:
      if (allow_empty != 0) goto <D.20485>; else goto <D.20488>;
      <D.20488>:
      length.20 = length;
      if (length.20 > 0) goto <D.20485>; else goto <D.20486>;
      <D.20485>:
      iftmp.19 = 1;
      goto <D.20487>;
      <D.20486>:
      iftmp.19 = 0;
      <D.20487>:
      D.20473 = iftmp.19;
      return D.20473;
    }
  finally
    {
      length = {CLOBBER};
    }
}


is_valid_guid (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.20492;
  struct MonoStreamHeader * D.20493;
  gboolean D.20494;
  int iftmp.21;
  unsigned int D.20498;
  unsigned int D.20500;
  struct OffsetAndSize guids;

  try
    {
      D.20492 = ctx->image;
      D.20493 = &D.20492->heap_guid;
      guids = get_metadata_stream (ctx, D.20493); [return slot optimization]
      D.20498 = guids.size;
      if (D.20498 > 7) goto <D.20499>; else goto <D.20496>;
      <D.20499>:
      D.20498 = guids.size;
      D.20500 = D.20498 + 4294967288;
      if (D.20500 >= offset) goto <D.20501>; else goto <D.20496>;
      <D.20501>:
      iftmp.21 = 1;
      goto <D.20497>;
      <D.20496>:
      iftmp.21 = 0;
      <D.20497>:
      D.20494 = iftmp.21;
      return D.20494;
    }
  finally
    {
      guids = {CLOBBER};
    }
}


verify_typedef_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.20504;
  unsigned int D.20505;
  unsigned int D.20506;
  int D.20509;
  gchar * D.20512;
  struct GSList * D.20513;
  struct GSList * D.20514;
  unsigned int D.20515;
  unsigned int D.20516;
  gchar * D.20521;
  struct GSList * D.20522;
  unsigned int D.20523;
  gchar * D.20528;
  struct GSList * D.20529;
  unsigned int D.20530;
  gchar * D.20535;
  struct GSList * D.20536;
  unsigned int D.20537;
  gchar * D.20542;
  struct GSList * D.20543;
  unsigned int D.20544;
  unsigned int D.20545;
  gchar * D.20550;
  struct GSList * D.20551;
  unsigned int D.20554;
  int D.20556;
  gchar * D.20559;
  struct GSList * D.20560;
  unsigned int D.20561;
  int D.20564;
  gchar * D.20569;
  struct GSList * D.20570;
  unsigned int D.20571;
  int D.20574;
  gchar * D.20579;
  struct GSList * D.20580;
  unsigned int D.20583;
  gchar * D.20588;
  struct GSList * D.20589;
  unsigned int D.20590;
  int D.20593;
  unsigned int D.20594;
  int D.20595;
  gchar * D.20600;
  struct GSList * D.20601;
  unsigned int D.20602;
  gchar * D.20607;
  struct GSList * D.20608;
  <unnamed-unsigned:24> D.20609;
  int D.20610;
  int D.20611;
  unsigned int D.20612;
  gchar * D.20617;
  struct GSList * D.20618;
  gchar * D.20623;
  struct GSList * D.20624;
  unsigned int D.20625;
  gchar * D.20630;
  struct GSList * D.20631;
  <unnamed-unsigned:24> D.20632;
  int D.20633;
  int D.20634;
  unsigned int D.20635;
  gchar * D.20640;
  struct GSList * D.20641;
  gchar * D.20646;
  struct GSList * D.20647;
  <unnamed-unsigned:24> D.20648;
  int D.20649;
  struct MonoTableInfo * table;
  guint32 data[6];
  guint32 fieldlist;
  guint32 methodlist;
  guint32 visibility;
  int i;

  try
    {
      D.20504 = ctx->image;
      table = &D.20504->tables[2];
      fieldlist = 1;
      methodlist = 1;
      D.20505 = BIT_FIELD_REF <*table, 32, 32>;
      D.20506 = D.20505 & 16777215;
      if (D.20506 == 0) goto <D.20507>; else goto <D.20508>;
      <D.20507>:
      D.20509 = ctx->report_error;
      if (D.20509 != 0) goto <D.20510>; else goto <D.20511>;
      <D.20510>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20512 = monoeg_g_strdup_printf ("Typedef table must have exactly at least one row");
        vinfo->info.message = D.20512;
        vinfo->exception_type = 3;
        D.20513 = ctx->errors;
        D.20514 = monoeg_g_slist_prepend (D.20513, vinfo);
        ctx->errors = D.20514;
      }
      <D.20511>:
      ctx->valid = 0;
      return;
      <D.20508>:
      i = 0;
      goto <D.18379>;
      <D.18378>:
      mono_metadata_decode_row (table, i, &data, 6);
      D.20515 = data[0];
      D.20516 = D.20515 & 4280861248;
      if (D.20516 != 0) goto <D.20517>; else goto <D.20518>;
      <D.20517>:
      D.20509 = ctx->report_error;
      if (D.20509 != 0) goto <D.20519>; else goto <D.20520>;
      <D.20519>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20515 = data[0];
        D.20521 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid flags field 0x%08x", i, D.20515);
        vinfo->info.message = D.20521;
        vinfo->exception_type = 3;
        D.20513 = ctx->errors;
        D.20522 = monoeg_g_slist_prepend (D.20513, vinfo);
        ctx->errors = D.20522;
      }
      <D.20520>:
      ctx->valid = 0;
      return;
      <D.20518>:
      D.20515 = data[0];
      D.20523 = D.20515 & 24;
      if (D.20523 == 24) goto <D.20524>; else goto <D.20525>;
      <D.20524>:
      D.20509 = ctx->report_error;
      if (D.20509 != 0) goto <D.20526>; else goto <D.20527>;
      <D.20526>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20528 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid class layout 0x18", i);
        vinfo->info.message = D.20528;
        vinfo->exception_type = 3;
        D.20513 = ctx->errors;
        D.20529 = monoeg_g_slist_prepend (D.20513, vinfo);
        ctx->errors = D.20529;
      }
      <D.20527>:
      ctx->valid = 0;
      return;
      <D.20525>:
      D.20515 = data[0];
      D.20530 = D.20515 & 196608;
      if (D.20530 == 196608) goto <D.20531>; else goto <D.20532>;
      <D.20531>:
      D.20509 = ctx->report_error;
      if (D.20509 != 0) goto <D.20533>; else goto <D.20534>;
      <D.20533>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20535 = monoeg_g_strdup_printf ("Invalid typedef row %d mono doesn\'t support custom string format", i);
        vinfo->info.message = D.20535;
        vinfo->exception_type = 3;
        D.20513 = ctx->errors;
        D.20536 = monoeg_g_slist_prepend (D.20513, vinfo);
        ctx->errors = D.20536;
      }
      <D.20534>:
      ctx->valid = 0;
      return;
      <D.20532>:
      D.20515 = data[0];
      D.20537 = D.20515 & 12582912;
      if (D.20537 != 0) goto <D.20538>; else goto <D.20539>;
      <D.20538>:
      D.20509 = ctx->report_error;
      if (D.20509 != 0) goto <D.20540>; else goto <D.20541>;
      <D.20540>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20542 = monoeg_g_strdup_printf ("Invalid typedef row %d mono doesn\'t support custom string format", i);
        vinfo->info.message = D.20542;
        vinfo->exception_type = 3;
        D.20513 = ctx->errors;
        D.20543 = monoeg_g_slist_prepend (D.20513, vinfo);
        ctx->errors = D.20543;
      }
      <D.20541>:
      ctx->valid = 0;
      return;
      <D.20539>:
      D.20544 = BIT_FIELD_REF <data, 32, 0>;
      D.20545 = D.20544 & 160;
      if (D.20545 == 32) goto <D.20546>; else goto <D.20547>;
      <D.20546>:
      D.20509 = ctx->report_error;
      if (D.20509 != 0) goto <D.20548>; else goto <D.20549>;
      <D.20548>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20550 = monoeg_g_strdup_printf ("Invalid typedef row %d for interface type must be abstract", i);
        vinfo->info.message = D.20550;
        vinfo->exception_type = 3;
        D.20513 = ctx->errors;
        D.20551 = monoeg_g_slist_prepend (D.20513, vinfo);
        ctx->errors = D.20551;
      }
      <D.20549>:
      ctx->valid = 0;
      return;
      <D.20547>:
      D.20554 = data[1];
      if (D.20554 == 0) goto <D.20552>; else goto <D.20555>;
      <D.20555>:
      D.20554 = data[1];
      D.20556 = is_valid_non_empty_string (ctx, D.20554);
      if (D.20556 == 0) goto <D.20552>; else goto <D.20553>;
      <D.20552>:
      D.20509 = ctx->report_error;
      if (D.20509 != 0) goto <D.20557>; else goto <D.20558>;
      <D.20557>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20554 = data[1];
        D.20559 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid name token %08x", i, D.20554);
        vinfo->info.message = D.20559;
        vinfo->exception_type = 3;
        D.20513 = ctx->errors;
        D.20560 = monoeg_g_slist_prepend (D.20513, vinfo);
        ctx->errors = D.20560;
      }
      <D.20558>:
      ctx->valid = 0;
      return;
      <D.20553>:
      D.20561 = data[2];
      if (D.20561 != 0) goto <D.20562>; else goto <D.20563>;
      <D.20562>:
      D.20561 = data[2];
      D.20564 = is_valid_non_empty_string (ctx, D.20561);
      if (D.20564 == 0) goto <D.20565>; else goto <D.20566>;
      <D.20565>:
      D.20509 = ctx->report_error;
      if (D.20509 != 0) goto <D.20567>; else goto <D.20568>;
      <D.20567>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20561 = data[2];
        D.20569 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid namespace token %08x", i, D.20561);
        vinfo->info.message = D.20569;
        vinfo->exception_type = 3;
        D.20513 = ctx->errors;
        D.20570 = monoeg_g_slist_prepend (D.20513, vinfo);
        ctx->errors = D.20570;
      }
      <D.20568>:
      ctx->valid = 0;
      return;
      <D.20566>:
      <D.20563>:
      D.20571 = data[3];
      if (D.20571 != 0) goto <D.20572>; else goto <D.20573>;
      <D.20572>:
      D.20571 = data[3];
      D.20574 = is_valid_coded_index (ctx, 0, D.20571);
      if (D.20574 == 0) goto <D.20575>; else goto <D.20576>;
      <D.20575>:
      D.20509 = ctx->report_error;
      if (D.20509 != 0) goto <D.20577>; else goto <D.20578>;
      <D.20577>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20571 = data[3];
        D.20579 = monoeg_g_strdup_printf ("Invalid typedef row %d extend field coded index 0x%08x", i, D.20571);
        vinfo->info.message = D.20579;
        vinfo->exception_type = 3;
        D.20513 = ctx->errors;
        D.20580 = monoeg_g_slist_prepend (D.20513, vinfo);
        ctx->errors = D.20580;
      }
      <D.20578>:
      ctx->valid = 0;
      return;
      <D.20576>:
      <D.20573>:
      D.20571 = data[3];
      if (D.20571 != 0) goto <D.20581>; else goto <D.20582>;
      <D.20581>:
      D.20571 = data[3];
      D.20583 = get_coded_index_token (0, D.20571);
      if (D.20583 == 0) goto <D.20584>; else goto <D.20585>;
      <D.20584>:
      D.20509 = ctx->report_error;
      if (D.20509 != 0) goto <D.20586>; else goto <D.20587>;
      <D.20586>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20571 = data[3];
        D.20588 = monoeg_g_strdup_printf ("Invalid typedef row %d zero coded extend field coded index 0x%08x", i, D.20571);
        vinfo->info.message = D.20588;
        vinfo->exception_type = 3;
        D.20513 = ctx->errors;
        D.20589 = monoeg_g_slist_prepend (D.20513, vinfo);
        ctx->errors = D.20589;
      }
      <D.20587>:
      ctx->valid = 0;
      return;
      <D.20585>:
      <D.20582>:
      D.20515 = data[0];
      visibility = D.20515 & 7;
      D.20590 = visibility + 4294967294;
      if (D.20590 <= 5) goto <D.20591>; else goto <D.20592>;
      <D.20591>:
      D.20593 = i + 1;
      D.20594 = (unsigned int) D.20593;
      D.20595 = search_sorted_table (ctx, 41, 0, D.20594);
      if (D.20595 == -1) goto <D.20596>; else goto <D.20597>;
      <D.20596>:
      D.20509 = ctx->report_error;
      if (D.20509 != 0) goto <D.20598>; else goto <D.20599>;
      <D.20598>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20600 = monoeg_g_strdup_printf ("Invalid typedef row %d has nested visibility but no rows in the NestedClass table", i);
        vinfo->info.message = D.20600;
        vinfo->exception_type = 3;
        D.20513 = ctx->errors;
        D.20601 = monoeg_g_slist_prepend (D.20513, vinfo);
        ctx->errors = D.20601;
      }
      <D.20599>:
      ctx->valid = 0;
      return;
      <D.20597>:
      <D.20592>:
      D.20602 = data[4];
      if (D.20602 == 0) goto <D.20603>; else goto <D.20604>;
      <D.20603>:
      D.20509 = ctx->report_error;
      if (D.20509 != 0) goto <D.20605>; else goto <D.20606>;
      <D.20605>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20607 = monoeg_g_strdup_printf ("Invalid typedef row %d FieldList be be >= 1", i);
        vinfo->info.message = D.20607;
        vinfo->exception_type = 3;
        D.20513 = ctx->errors;
        D.20608 = monoeg_g_slist_prepend (D.20513, vinfo);
        ctx->errors = D.20608;
      }
      <D.20606>:
      ctx->valid = 0;
      return;
      <D.20604>:
      D.20602 = data[4];
      D.20504 = ctx->image;
      D.20609 = D.20504->tables[4].rows;
      D.20610 = (int) D.20609;
      D.20611 = D.20610 + 1;
      D.20612 = (unsigned int) D.20611;
      if (D.20602 > D.20612) goto <D.20613>; else goto <D.20614>;
      <D.20613>:
      D.20509 = ctx->report_error;
      if (D.20509 != 0) goto <D.20615>; else goto <D.20616>;
      <D.20615>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20602 = data[4];
        D.20617 = monoeg_g_strdup_printf ("Invalid typedef row %d FieldList rowid 0x%08x is out of range", i, D.20602);
        vinfo->info.message = D.20617;
        vinfo->exception_type = 3;
        D.20513 = ctx->errors;
        D.20618 = monoeg_g_slist_prepend (D.20513, vinfo);
        ctx->errors = D.20618;
      }
      <D.20616>:
      ctx->valid = 0;
      return;
      <D.20614>:
      D.20602 = data[4];
      if (D.20602 < fieldlist) goto <D.20619>; else goto <D.20620>;
      <D.20619>:
      D.20509 = ctx->report_error;
      if (D.20509 != 0) goto <D.20621>; else goto <D.20622>;
      <D.20621>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20602 = data[4];
        D.20623 = monoeg_g_strdup_printf ("Invalid typedef row %d FieldList rowid 0x%08x can\'t be smaller than of previous row 0x%08x", i, D.20602, fieldlist);
        vinfo->info.message = D.20623;
        vinfo->exception_type = 3;
        D.20513 = ctx->errors;
        D.20624 = monoeg_g_slist_prepend (D.20513, vinfo);
        ctx->errors = D.20624;
      }
      <D.20622>:
      ctx->valid = 0;
      return;
      <D.20620>:
      D.20625 = data[5];
      if (D.20625 == 0) goto <D.20626>; else goto <D.20627>;
      <D.20626>:
      D.20509 = ctx->report_error;
      if (D.20509 != 0) goto <D.20628>; else goto <D.20629>;
      <D.20628>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20630 = monoeg_g_strdup_printf ("Invalid typedef row %d MethodList be be >= 1", i);
        vinfo->info.message = D.20630;
        vinfo->exception_type = 3;
        D.20513 = ctx->errors;
        D.20631 = monoeg_g_slist_prepend (D.20513, vinfo);
        ctx->errors = D.20631;
      }
      <D.20629>:
      ctx->valid = 0;
      return;
      <D.20627>:
      D.20625 = data[5];
      D.20504 = ctx->image;
      D.20632 = D.20504->tables[6].rows;
      D.20633 = (int) D.20632;
      D.20634 = D.20633 + 1;
      D.20635 = (unsigned int) D.20634;
      if (D.20625 > D.20635) goto <D.20636>; else goto <D.20637>;
      <D.20636>:
      D.20509 = ctx->report_error;
      if (D.20509 != 0) goto <D.20638>; else goto <D.20639>;
      <D.20638>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20625 = data[5];
        D.20640 = monoeg_g_strdup_printf ("Invalid typedef row %d MethodList rowid 0x%08x is out of range", i, D.20625);
        vinfo->info.message = D.20640;
        vinfo->exception_type = 3;
        D.20513 = ctx->errors;
        D.20641 = monoeg_g_slist_prepend (D.20513, vinfo);
        ctx->errors = D.20641;
      }
      <D.20639>:
      ctx->valid = 0;
      return;
      <D.20637>:
      D.20625 = data[5];
      if (D.20625 < methodlist) goto <D.20642>; else goto <D.20643>;
      <D.20642>:
      D.20509 = ctx->report_error;
      if (D.20509 != 0) goto <D.20644>; else goto <D.20645>;
      <D.20644>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20625 = data[5];
        D.20646 = monoeg_g_strdup_printf ("Invalid typedef row %d MethodList rowid 0x%08x can\'t be smaller than of previous row 0x%08x", i, D.20625, methodlist);
        vinfo->info.message = D.20646;
        vinfo->exception_type = 3;
        D.20513 = ctx->errors;
        D.20647 = monoeg_g_slist_prepend (D.20513, vinfo);
        ctx->errors = D.20647;
      }
      <D.20645>:
      ctx->valid = 0;
      return;
      <D.20643>:
      fieldlist = data[4];
      methodlist = data[5];
      i = i + 1;
      <D.18379>:
      D.20648 = table->rows;
      D.20649 = (int) D.20648;
      if (D.20649 > i) goto <D.18378>; else goto <D.18380>;
      <D.18380>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


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

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


is_valid_coded_index_with_image (struct MonoImage * image, int token_kind, guint32 coded_token)
{
  int token_kind.22;
  unsigned char D.20657;
  int token_kind.23;
  unsigned char D.20659;
  int bits.24;
  int D.20661;
  int D.20662;
  unsigned int D.20663;
  gboolean D.20666;
  unsigned int token_kind.25;
  unsigned int D.20668;
  unsigned char D.20669;
  <unnamed-unsigned:24> D.20672;
  unsigned int D.20673;
  _Bool D.20674;
  guint32 bits;
  guint32 table_count;
  guint32 table;
  guint32 token;

  token_kind.22 = token_kind;
  token_kind = token_kind.22 + 1;
  D.20657 = coded_index_desc[token_kind.22];
  bits = (guint32) D.20657;
  token_kind.23 = token_kind;
  token_kind = token_kind.23 + 1;
  D.20659 = coded_index_desc[token_kind.23];
  table_count = (guint32) D.20659;
  bits.24 = (int) bits;
  D.20661 = 1 << bits.24;
  D.20662 = D.20661 + -1;
  D.20663 = (unsigned int) D.20662;
  table = D.20663 & coded_token;
  bits.24 = (int) bits;
  token = coded_token >> bits.24;
  if (table >= table_count) goto <D.20664>; else goto <D.20665>;
  <D.20664>:
  D.20666 = 0;
  return D.20666;
  <D.20665>:
  token_kind.25 = (unsigned int) token_kind;
  D.20668 = token_kind.25 + table;
  D.20669 = coded_index_desc[D.20668];
  table = (guint32) D.20669;
  if (table == 255) goto <D.20670>; else goto <D.20671>;
  <D.20670>:
  D.20666 = 0;
  return D.20666;
  <D.20671>:
  D.20672 = image->tables[table].rows;
  D.20673 = (unsigned int) D.20672;
  D.20674 = D.20673 >= token;
  D.20666 = (gboolean) D.20674;
  return D.20666;
}


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

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


search_sorted_table (struct VerifyContext * ctx, int table, int column, guint32 coded_token)
{
  struct MonoImage * D.20680;
  unsigned int D.20681;
  unsigned int D.20682;
  <unnamed-unsigned:24> D.20683;
  unsigned int D.20684;
  unsigned char D.20685;
  unsigned int D.20686;
  int D.20689;
  int res.27;
  int base.28;
  int D.20692;
  int D.20693;
  struct MonoTableInfo * tinfo;
  struct RowLocator locator;
  const char * res;
  const char * base;

  try
    {
      D.20680 = ctx->image;
      tinfo = &D.20680->tables[table];
      locator.token = coded_token;
      D.20681 = get_col_offset (ctx, table, column);
      locator.col_offset = D.20681;
      D.20682 = get_col_size (ctx, table, column);
      locator.col_size = D.20682;
      locator.table = tinfo;
      base = tinfo->base;
      D.20683 = tinfo->rows;
      D.20684 = (unsigned int) D.20683;
      D.20685 = tinfo->row_size;
      D.20686 = (unsigned int) D.20685;
      res = mono_binary_search (&locator, base, D.20684, D.20686, token_locator);
      if (res == 0B) goto <D.20687>; else goto <D.20688>;
      <D.20687>:
      D.20689 = -1;
      return D.20689;
      <D.20688>:
      res.27 = (int) res;
      base.28 = (int) base;
      D.20692 = res.27 - base.28;
      D.20685 = tinfo->row_size;
      D.20693 = (int) D.20685;
      D.20689 = D.20692 / D.20693;
      return D.20689;
    }
  finally
    {
      locator = {CLOBBER};
    }
}


token_locator (const void * a, const void * b)
{
  guint32 iftmp.29;
  unsigned int D.20697;
  unsigned int D.20700;
  const unsigned char * D.20701;
  short unsigned int D.20702;
  int D.20704;
  unsigned int D.20705;
  int D.20706;
  int token.30;
  struct RowLocator * loc;
  const unsigned char * row;
  guint32 token;

  loc = a;
  row = b;
  D.20697 = loc->col_size;
  if (D.20697 == 2) goto <D.20698>; else goto <D.20699>;
  <D.20698>:
  D.20700 = loc->col_offset;
  D.20701 = row + D.20700;
  D.20702 = mono_read16 (D.20701);
  iftmp.29 = (guint32) D.20702;
  goto <D.20703>;
  <D.20699>:
  D.20700 = loc->col_offset;
  D.20701 = row + D.20700;
  iftmp.29 = mono_read32 (D.20701);
  <D.20703>:
  token = iftmp.29;
  D.20705 = loc->token;
  D.20706 = (int) D.20705;
  token.30 = (int) token;
  D.20704 = D.20706 - token.30;
  return D.20704;
}


get_col_offset (struct VerifyContext * ctx, int table, int column)
{
  struct MonoImage * D.20709;
  int D.20710;
  unsigned int D.20711;
  unsigned int D.20712;
  unsigned int D.20713;
  int column.31;
  guint32 D.20715;
  guint32 bitfield;
  guint32 offset;

  D.20709 = ctx->image;
  bitfield = D.20709->tables[table].size_bitfield;
  offset = 0;
  goto <D.17636>;
  <D.17635>:
  D.20710 = column * 2;
  D.20711 = bitfield >> D.20710;
  D.20712 = D.20711 & 3;
  D.20713 = D.20712 + offset;
  offset = D.20713 + 1;
  <D.17636>:
  column.31 = column;
  column = column.31 + -1;
  if (column.31 > 0) goto <D.17635>; else goto <D.17637>;
  <D.17637>:
  D.20715 = offset;
  return D.20715;
}


get_col_size (struct VerifyContext * ctx, int table, int column)
{
  guint32 D.20717;
  struct MonoImage * D.20718;
  unsigned int D.20719;
  int D.20720;
  unsigned int D.20721;
  unsigned int D.20722;

  D.20718 = ctx->image;
  D.20719 = D.20718->tables[table].size_bitfield;
  D.20720 = column * 2;
  D.20721 = D.20719 >> D.20720;
  D.20722 = D.20721 & 3;
  D.20717 = D.20722 + 1;
  return D.20717;
}


verify_field_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.20724;
  <unnamed-unsigned:24> D.20725;
  int D.20726;
  unsigned int D.20729;
  int D.20732;
  gchar * D.20735;
  struct GSList * D.20736;
  struct GSList * D.20737;
  unsigned int D.20738;
  gchar * D.20743;
  struct GSList * D.20744;
  unsigned int D.20745;
  gchar * D.20750;
  struct GSList * D.20751;
  unsigned int D.20752;
  gchar * D.20757;
  struct GSList * D.20758;
  unsigned int D.20759;
  gchar * D.20764;
  struct GSList * D.20765;
  unsigned int D.20766;
  unsigned int i.32;
  unsigned int D.20770;
  int D.20771;
  gchar * D.20776;
  struct GSList * D.20777;
  unsigned int D.20778;
  unsigned int D.20781;
  int D.20782;
  gchar * D.20787;
  struct GSList * D.20788;
  unsigned int D.20789;
  unsigned int D.20792;
  int D.20793;
  gchar * D.20798;
  struct GSList * D.20799;
  unsigned int D.20800;
  int D.20803;
  unsigned int D.20804;
  int D.20805;
  gchar * D.20810;
  struct GSList * D.20811;
  unsigned int D.20814;
  int D.20816;
  gchar * D.20819;
  struct GSList * D.20820;
  unsigned int D.20821;
  int D.20824;
  gchar * D.20829;
  struct GSList * D.20830;
  unsigned int D.20833;
  gchar * D.20838;
  struct GSList * D.20839;
  gchar * D.20846;
  struct GSList * D.20847;
  <unnamed-unsigned:24> D.20848;
  int D.20849;
  struct MonoTableInfo * table;
  guint32 data[3];
  guint32 flags;
  guint32 module_field_list;
  int i;

  try
    {
      D.20724 = ctx->image;
      table = &D.20724->tables[4];
      module_field_list = 4294967295;
      D.20724 = ctx->image;
      D.20725 = D.20724->tables[2].rows;
      D.20726 = (int) D.20725;
      if (D.20726 > 1) goto <D.20727>; else goto <D.20728>;
      <D.20727>:
      {
        struct MonoTableInfo * type;

        D.20724 = ctx->image;
        type = &D.20724->tables[2];
        module_field_list = mono_metadata_decode_row_col (type, 1, 4);
      }
      <D.20728>:
      i = 0;
      goto <D.18421>;
      <D.18420>:
      mono_metadata_decode_row (table, i, &data, 3);
      flags = data[0];
      D.20729 = flags & 18440;
      if (D.20729 != 0) goto <D.20730>; else goto <D.20731>;
      <D.20730>:
      D.20732 = ctx->report_error;
      if (D.20732 != 0) goto <D.20733>; else goto <D.20734>;
      <D.20733>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20735 = monoeg_g_strdup_printf ("Invalid field row %d invalid flags field 0x%08x", i, flags);
        vinfo->info.message = D.20735;
        vinfo->exception_type = 3;
        D.20736 = ctx->errors;
        D.20737 = monoeg_g_slist_prepend (D.20736, vinfo);
        ctx->errors = D.20737;
      }
      <D.20734>:
      ctx->valid = 0;
      return;
      <D.20731>:
      D.20738 = flags & 7;
      if (D.20738 == 7) goto <D.20739>; else goto <D.20740>;
      <D.20739>:
      D.20732 = ctx->report_error;
      if (D.20732 != 0) goto <D.20741>; else goto <D.20742>;
      <D.20741>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20743 = monoeg_g_strdup_printf ("Invalid field row %d invalid field visibility 0x7", i);
        vinfo->info.message = D.20743;
        vinfo->exception_type = 3;
        D.20736 = ctx->errors;
        D.20744 = monoeg_g_slist_prepend (D.20736, vinfo);
        ctx->errors = D.20744;
      }
      <D.20742>:
      ctx->valid = 0;
      return;
      <D.20740>:
      D.20745 = flags & 96;
      if (D.20745 == 96) goto <D.20746>; else goto <D.20747>;
      <D.20746>:
      D.20732 = ctx->report_error;
      if (D.20732 != 0) goto <D.20748>; else goto <D.20749>;
      <D.20748>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20750 = monoeg_g_strdup_printf ("Invalid field row %d cannot be InitOnly and Literal at the same time", i);
        vinfo->info.message = D.20750;
        vinfo->exception_type = 3;
        D.20736 = ctx->errors;
        D.20751 = monoeg_g_slist_prepend (D.20736, vinfo);
        ctx->errors = D.20751;
      }
      <D.20749>:
      ctx->valid = 0;
      return;
      <D.20747>:
      D.20752 = flags & 1536;
      if (D.20752 == 1024) goto <D.20753>; else goto <D.20754>;
      <D.20753>:
      D.20732 = ctx->report_error;
      if (D.20732 != 0) goto <D.20755>; else goto <D.20756>;
      <D.20755>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20757 = monoeg_g_strdup_printf ("Invalid field row %d is RTSpecialName but not SpecialName", i);
        vinfo->info.message = D.20757;
        vinfo->exception_type = 3;
        D.20736 = ctx->errors;
        D.20758 = monoeg_g_slist_prepend (D.20736, vinfo);
        ctx->errors = D.20758;
      }
      <D.20756>:
      ctx->valid = 0;
      return;
      <D.20754>:
      D.20759 = flags & 80;
      if (D.20759 == 64) goto <D.20760>; else goto <D.20761>;
      <D.20760>:
      D.20732 = ctx->report_error;
      if (D.20732 != 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 is Literal but not Static", i);
        vinfo->info.message = D.20764;
        vinfo->exception_type = 3;
        D.20736 = ctx->errors;
        D.20765 = monoeg_g_slist_prepend (D.20736, vinfo);
        ctx->errors = D.20765;
      }
      <D.20763>:
      ctx->valid = 0;
      return;
      <D.20761>:
      D.20766 = flags & 4096;
      if (D.20766 != 0) goto <D.20767>; else goto <D.20768>;
      <D.20767>:
      i.32 = (unsigned int) i;
      D.20770 = make_coded_token (32, 4, i.32);
      D.20771 = search_sorted_table (ctx, 13, 0, D.20770);
      if (D.20771 == -1) goto <D.20772>; else goto <D.20773>;
      <D.20772>:
      D.20732 = ctx->report_error;
      if (D.20732 != 0) goto <D.20774>; else goto <D.20775>;
      <D.20774>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20776 = 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.20776;
        vinfo->exception_type = 3;
        D.20736 = ctx->errors;
        D.20777 = monoeg_g_slist_prepend (D.20736, vinfo);
        ctx->errors = D.20777;
      }
      <D.20775>:
      ctx->valid = 0;
      return;
      <D.20773>:
      <D.20768>:
      D.20778 = flags & 32768;
      if (D.20778 != 0) goto <D.20779>; else goto <D.20780>;
      <D.20779>:
      i.32 = (unsigned int) i;
      D.20781 = make_coded_token (5, 4, i.32);
      D.20782 = search_sorted_table (ctx, 11, 2, D.20781);
      if (D.20782 == -1) goto <D.20783>; else goto <D.20784>;
      <D.20783>:
      D.20732 = ctx->report_error;
      if (D.20732 != 0) goto <D.20785>; else goto <D.20786>;
      <D.20785>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20787 = 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.20787;
        vinfo->exception_type = 3;
        D.20736 = ctx->errors;
        D.20788 = monoeg_g_slist_prepend (D.20736, vinfo);
        ctx->errors = D.20788;
      }
      <D.20786>:
      ctx->valid = 0;
      return;
      <D.20784>:
      <D.20780>:
      D.20789 = flags & 64;
      if (D.20789 != 0) goto <D.20790>; else goto <D.20791>;
      <D.20790>:
      i.32 = (unsigned int) i;
      D.20792 = make_coded_token (5, 4, i.32);
      D.20793 = search_sorted_table (ctx, 11, 2, D.20792);
      if (D.20793 == -1) goto <D.20794>; else goto <D.20795>;
      <D.20794>:
      D.20732 = ctx->report_error;
      if (D.20732 != 0) goto <D.20796>; else goto <D.20797>;
      <D.20796>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20798 = 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.20798;
        vinfo->exception_type = 3;
        D.20736 = ctx->errors;
        D.20799 = monoeg_g_slist_prepend (D.20736, vinfo);
        ctx->errors = D.20799;
      }
      <D.20797>:
      ctx->valid = 0;
      return;
      <D.20795>:
      <D.20791>:
      D.20800 = flags & 256;
      if (D.20800 != 0) goto <D.20801>; else goto <D.20802>;
      <D.20801>:
      D.20803 = i + 1;
      D.20804 = (unsigned int) D.20803;
      D.20805 = search_sorted_table (ctx, 29, 1, D.20804);
      if (D.20805 == -1) goto <D.20806>; else goto <D.20807>;
      <D.20806>:
      D.20732 = ctx->report_error;
      if (D.20732 != 0) goto <D.20808>; else goto <D.20809>;
      <D.20808>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20810 = 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.20810;
        vinfo->exception_type = 3;
        D.20736 = ctx->errors;
        D.20811 = monoeg_g_slist_prepend (D.20736, vinfo);
        ctx->errors = D.20811;
      }
      <D.20809>:
      ctx->valid = 0;
      return;
      <D.20807>:
      <D.20802>:
      D.20814 = data[1];
      if (D.20814 == 0) goto <D.20812>; else goto <D.20815>;
      <D.20815>:
      D.20814 = data[1];
      D.20816 = is_valid_non_empty_string (ctx, D.20814);
      if (D.20816 == 0) goto <D.20812>; else goto <D.20813>;
      <D.20812>:
      D.20732 = ctx->report_error;
      if (D.20732 != 0) goto <D.20817>; else goto <D.20818>;
      <D.20817>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20814 = data[1];
        D.20819 = monoeg_g_strdup_printf ("Invalid field row %d invalid name token %08x", i, D.20814);
        vinfo->info.message = D.20819;
        vinfo->exception_type = 3;
        D.20736 = ctx->errors;
        D.20820 = monoeg_g_slist_prepend (D.20736, vinfo);
        ctx->errors = D.20820;
      }
      <D.20818>:
      ctx->valid = 0;
      return;
      <D.20813>:
      D.20821 = data[2];
      if (D.20821 != 0) goto <D.20822>; else goto <D.20823>;
      <D.20822>:
      D.20821 = data[2];
      D.20824 = is_valid_blob_object (ctx, D.20821, 1);
      if (D.20824 == 0) goto <D.20825>; else goto <D.20826>;
      <D.20825>:
      D.20732 = ctx->report_error;
      if (D.20732 != 0) goto <D.20827>; else goto <D.20828>;
      <D.20827>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20821 = data[2];
        D.20829 = monoeg_g_strdup_printf ("Invalid field row %d invalid signature blob token 0x%x", i, D.20821);
        vinfo->info.message = D.20829;
        vinfo->exception_type = 3;
        D.20736 = ctx->errors;
        D.20830 = monoeg_g_slist_prepend (D.20736, vinfo);
        ctx->errors = D.20830;
      }
      <D.20828>:
      ctx->valid = 0;
      return;
      <D.20826>:
      <D.20823>:
      D.20803 = i + 1;
      D.20804 = (unsigned int) D.20803;
      if (D.20804 < module_field_list) goto <D.20831>; else goto <D.20832>;
      <D.20831>:
      {
        guint32 access;

        access = flags & 7;
        D.20833 = flags & 16;
        if (D.20833 == 0) goto <D.20834>; else goto <D.20835>;
        <D.20834>:
        D.20732 = ctx->report_error;
        if (D.20732 != 0) goto <D.20836>; else goto <D.20837>;
        <D.20836>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.20838 = monoeg_g_strdup_printf ("Invalid field row %d is a global variable but is not static", i);
          vinfo->info.message = D.20838;
          vinfo->exception_type = 3;
          D.20736 = ctx->errors;
          D.20839 = monoeg_g_slist_prepend (D.20736, vinfo);
          ctx->errors = D.20839;
        }
        <D.20837>:
        ctx->valid = 0;
        return;
        <D.20835>:
        if (access > 1) goto <D.20840>; else goto <D.20841>;
        <D.20840>:
        if (access != 6) goto <D.20842>; else goto <D.20843>;
        <D.20842>:
        D.20732 = ctx->report_error;
        if (D.20732 != 0) goto <D.20844>; else goto <D.20845>;
        <D.20844>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.20846 = monoeg_g_strdup_printf ("Invalid field row %d is a global variable but have wrong visibility %x", i, access);
          vinfo->info.message = D.20846;
          vinfo->exception_type = 3;
          D.20736 = ctx->errors;
          D.20847 = monoeg_g_slist_prepend (D.20736, vinfo);
          ctx->errors = D.20847;
        }
        <D.20845>:
        ctx->valid = 0;
        return;
        <D.20843>:
        <D.20841>:
      }
      <D.20832>:
      i = i + 1;
      <D.18421>:
      D.20848 = table->rows;
      D.20849 = (int) D.20848;
      if (D.20849 > i) goto <D.18420>; else goto <D.18422>;
      <D.18422>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


make_coded_token (int kind, guint32 table, guint32 table_idx)
{
  int kind.33;
  unsigned char D.20854;
  int kind.34;
  unsigned char D.20856;
  int kind.35;
  unsigned char D.20858;
  unsigned int D.20859;
  guint32 D.20862;
  unsigned int D.20863;
  int bits.36;
  unsigned int D.20865;
  guint32 bits;
  guint32 tables;
  guint32 i;

  kind.33 = kind;
  kind = kind.33 + 1;
  D.20854 = coded_index_desc[kind.33];
  bits = (guint32) D.20854;
  kind.34 = kind;
  kind = kind.34 + 1;
  D.20856 = coded_index_desc[kind.34];
  tables = (guint32) D.20856;
  i = 0;
  goto <D.17695>;
  <D.17694>:
  kind.35 = kind;
  kind = kind.35 + 1;
  D.20858 = coded_index_desc[kind.35];
  D.20859 = (unsigned int) D.20858;
  if (D.20859 == table) goto <D.20860>; else goto <D.20861>;
  <D.20860>:
  D.20863 = table_idx + 1;
  bits.36 = (int) bits;
  D.20865 = D.20863 << bits.36;
  D.20862 = D.20865 | i;
  return D.20862;
  <D.20861>:
  i = i + 1;
  <D.17695>:
  if (i < tables) goto <D.17694>; else goto <D.17696>;
  <D.17696>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata-verify.c", 1012);
  D.20862 = 4294967295;
  return D.20862;
}


is_valid_blob_object (struct VerifyContext * ctx, guint32 offset, guint32 minsize)
{
  struct MonoImage * D.20867;
  struct MonoStreamHeader * D.20868;
  unsigned int D.20869;
  gboolean D.20872;
  const char * D.20873;
  unsigned int D.20874;
  sizetype D.20875;
  const char * D.20876;
  unsigned int D.20877;
  int D.20878;
  unsigned int entry_size.37;
  unsigned int bytes.38;
  unsigned int D.20885;
  unsigned int entry_size.39;
  int iftmp.40;
  unsigned int D.20892;
  unsigned int D.20894;
  struct OffsetAndSize blob;
  guint32 entry_size;
  guint32 bytes;

  try
    {
      D.20867 = ctx->image;
      D.20868 = &D.20867->heap_blob;
      blob = get_metadata_stream (ctx, D.20868); [return slot optimization]
      D.20869 = blob.size;
      if (D.20869 < offset) goto <D.20870>; else goto <D.20871>;
      <D.20870>:
      D.20872 = 0;
      return D.20872;
      <D.20871>:
      D.20873 = ctx->data;
      D.20874 = blob.offset;
      D.20875 = D.20874 + offset;
      D.20876 = D.20873 + D.20875;
      D.20869 = blob.size;
      D.20874 = blob.offset;
      D.20877 = D.20869 - D.20874;
      D.20878 = decode_value (D.20876, D.20877, &entry_size, &bytes);
      if (D.20878 == 0) goto <D.20879>; else goto <D.20880>;
      <D.20879>:
      D.20872 = 0;
      return D.20872;
      <D.20880>:
      entry_size.37 = entry_size;
      if (entry_size.37 < minsize) goto <D.20882>; else goto <D.20883>;
      <D.20882>:
      D.20872 = 0;
      return D.20872;
      <D.20883>:
      bytes.38 = bytes;
      D.20885 = ~bytes.38;
      entry_size.37 = entry_size;
      if (D.20885 < entry_size.37) goto <D.20886>; else goto <D.20887>;
      <D.20886>:
      D.20872 = 0;
      return D.20872;
      <D.20887>:
      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.20892 = offset + entry_size.37;
      D.20869 = blob.size;
      if (D.20892 <= D.20869) goto <D.20893>; else goto <D.20890>;
      <D.20893>:
      entry_size.37 = entry_size;
      D.20894 = ~entry_size.37;
      if (D.20894 >= offset) goto <D.20895>; else goto <D.20890>;
      <D.20895>:
      iftmp.40 = 1;
      goto <D.20891>;
      <D.20890>:
      iftmp.40 = 0;
      <D.20891>:
      D.20872 = iftmp.40;
      return D.20872;
    }
  finally
    {
      blob = {CLOBBER};
      entry_size = {CLOBBER};
      bytes = {CLOBBER};
    }
}


decode_value (const char * _ptr, unsigned int available, unsigned int * value, unsigned int * size)
{
  gboolean D.20900;
  unsigned int D.20901;
  signed char b.41;
  unsigned int D.20905;
  int D.20907;
  int D.20908;
  int D.20913;
  int D.20914;
  const unsigned char * D.20915;
  unsigned char D.20916;
  int D.20917;
  int D.20918;
  unsigned int D.20919;
  int D.20923;
  int D.20924;
  int D.20925;
  int D.20926;
  const unsigned char * D.20927;
  unsigned char D.20928;
  int D.20929;
  int D.20930;
  int D.20931;
  const unsigned char * D.20932;
  unsigned char D.20933;
  int D.20934;
  int D.20935;
  unsigned int D.20936;
  unsigned char b;
  const unsigned char * ptr;

  ptr = _ptr;
  if (available == 0) goto <D.20898>; else goto <D.20899>;
  <D.20898>:
  D.20900 = 0;
  return D.20900;
  <D.20899>:
  b = *ptr;
  *size = 0;
  D.20901 = *size;
  *value = D.20901;
  b.41 = (signed char) b;
  if (b.41 >= 0) goto <D.20903>; else goto <D.20904>;
  <D.20903>:
  *size = 1;
  D.20905 = (unsigned int) b;
  *value = D.20905;
  goto <D.20906>;
  <D.20904>:
  D.20907 = (int) b;
  D.20908 = D.20907 & 64;
  if (D.20908 == 0) goto <D.20909>; else goto <D.20910>;
  <D.20909>:
  if (available <= 1) goto <D.20911>; else goto <D.20912>;
  <D.20911>:
  D.20900 = 0;
  return D.20900;
  <D.20912>:
  *size = 2;
  D.20907 = (int) b;
  D.20913 = D.20907 & 63;
  D.20914 = D.20913 << 8;
  D.20915 = ptr + 1;
  D.20916 = *D.20915;
  D.20917 = (int) D.20916;
  D.20918 = D.20914 | D.20917;
  D.20919 = (unsigned int) D.20918;
  *value = D.20919;
  goto <D.20920>;
  <D.20910>:
  if (available <= 3) goto <D.20921>; else goto <D.20922>;
  <D.20921>:
  D.20900 = 0;
  return D.20900;
  <D.20922>:
  *size = 4;
  D.20907 = (int) b;
  D.20923 = D.20907 & 31;
  D.20924 = D.20923 << 24;
  D.20915 = ptr + 1;
  D.20916 = *D.20915;
  D.20917 = (int) D.20916;
  D.20925 = D.20917 << 16;
  D.20926 = D.20924 | D.20925;
  D.20927 = ptr + 2;
  D.20928 = *D.20927;
  D.20929 = (int) D.20928;
  D.20930 = D.20929 << 8;
  D.20931 = D.20926 | D.20930;
  D.20932 = ptr + 3;
  D.20933 = *D.20932;
  D.20934 = (int) D.20933;
  D.20935 = D.20931 | D.20934;
  D.20936 = (unsigned int) D.20935;
  *value = D.20936;
  <D.20920>:
  <D.20906>:
  D.20900 = 1;
  return D.20900;
}


verify_method_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.20938;
  <unnamed-unsigned:24> D.20939;
  int D.20940;
  unsigned int D.20943;
  int D.20946;
  gchar * D.20949;
  struct GSList * D.20950;
  struct GSList * D.20951;
  gchar * D.20956;
  struct GSList * D.20957;
  unsigned int D.20960;
  int D.20962;
  gchar * D.20965;
  struct GSList * D.20966;
  int D.18461;
  int iftmp.42;
  int D.18457;
  const char[6] * D.20970;
  unsigned char D.20971;
  int D.20972;
  unsigned char D.20973;
  int D.20974;
  const unsigned char * D.20979;
  unsigned char D.20980;
  int D.20981;
  const unsigned char * D.20982;
  unsigned char D.20983;
  int D.20984;
  const unsigned char * D.20989;
  unsigned char D.20990;
  int D.20991;
  const unsigned char * D.20992;
  unsigned char D.20993;
  int D.20994;
  const unsigned char * D.20999;
  unsigned char D.21000;
  int D.21001;
  const unsigned char * D.21002;
  unsigned char D.21003;
  int D.21004;
  _Bool D.21006;
  int D.18470;
  int iftmp.43;
  int D.18466;
  const char[7] * D.21010;
  unsigned char D.21011;
  int D.21012;
  unsigned char D.21013;
  int D.21014;
  const unsigned char * D.21019;
  unsigned char D.21020;
  int D.21021;
  const unsigned char * D.21022;
  unsigned char D.21023;
  int D.21024;
  const unsigned char * D.21029;
  unsigned char D.21030;
  int D.21031;
  const unsigned char * D.21032;
  unsigned char D.21033;
  int D.21034;
  const unsigned char * D.21039;
  unsigned char D.21040;
  int D.21041;
  const unsigned char * D.21042;
  unsigned char D.21043;
  int D.21044;
  _Bool D.21046;
  unsigned int i.44;
  unsigned int D.21051;
  int D.21052;
  gchar * D.21057;
  struct GSList * D.21058;
  unsigned int D.21059;
  unsigned int D.21062;
  gchar * D.21067;
  struct GSList * D.21068;
  unsigned int D.21069;
  unsigned int D.21072;
  gchar * D.21077;
  struct GSList * D.21078;
  unsigned int D.21079;
  gchar * D.21084;
  struct GSList * D.21085;
  unsigned int D.21086;
  gchar * D.21091;
  struct GSList * D.21092;
  unsigned int D.21095;
  int D.21098;
  gchar * D.21101;
  struct GSList * D.21102;
  unsigned int D.21103;
  gchar * D.21108;
  struct GSList * D.21109;
  int D.21110;
  unsigned int D.21111;
  gchar * D.21118;
  struct GSList * D.21119;
  unsigned int D.21120;
  gchar * D.21125;
  struct GSList * D.21126;
  gchar * D.21133;
  struct GSList * D.21134;
  unsigned int D.21135;
  gchar * D.21142;
  struct GSList * D.21143;
  gchar * D.21150;
  struct GSList * D.21151;
  gchar * D.21156;
  struct GSList * D.21157;
  unsigned int D.21164;
  gchar * D.21171;
  struct GSList * D.21172;
  gchar * D.21181;
  struct GSList * D.21182;
  unsigned int D.21187;
  gchar * D.21191;
  struct GSList * D.21192;
  gchar * D.21197;
  struct GSList * D.21198;
  gchar * D.21208;
  struct GSList * D.21209;
  gchar * D.21216;
  struct GSList * D.21217;
  unsigned int D.21218;
  int D.21219;
  gchar * D.21224;
  struct GSList * D.21225;
  unsigned int D.21226;
  gchar * D.21235;
  struct GSList * D.21236;
  gchar * D.21244;
  struct GSList * D.21245;
  unsigned int D.21246;
  int D.21249;
  gchar * D.21254;
  struct GSList * D.21255;
  unsigned int D.21256;
  gchar * D.21261;
  struct GSList * D.21262;
  gchar * D.21267;
  struct GSList * D.21268;
  <unnamed-unsigned:24> D.21269;
  int D.21270;
  int D.21271;
  unsigned int D.21272;
  gchar * D.21277;
  struct GSList * D.21278;
  <unnamed-unsigned:24> D.21279;
  int D.21280;
  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.20938 = ctx->image;
      table = &D.20938->tables[6];
      paramlist = 1;
      module_method_list = 4294967295;
      D.20938 = ctx->image;
      D.20939 = D.20938->tables[2].rows;
      D.20940 = (int) D.20939;
      if (D.20940 > 1) goto <D.20941>; else goto <D.20942>;
      <D.20941>:
      {
        struct MonoTableInfo * type;

        D.20938 = ctx->image;
        type = &D.20938->tables[2];
        module_method_list = mono_metadata_decode_row_col (type, 1, 5);
      }
      <D.20942>:
      i = 0;
      goto <D.18498>;
      <D.18497>:
      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.20943 = implflags & 60928;
      if (D.20943 != 0) goto <D.20944>; else goto <D.20945>;
      <D.20944>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.20947>; else goto <D.20948>;
      <D.20947>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20949 = monoeg_g_strdup_printf ("Invalid method row %d invalid implflags field 0x%08x", i, implflags);
        vinfo->info.message = D.20949;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.20951 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.20951;
      }
      <D.20948>:
      ctx->valid = 0;
      return;
      <D.20945>:
      if (access == 7) goto <D.20952>; else goto <D.20953>;
      <D.20952>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.20954>; else goto <D.20955>;
      <D.20954>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.20956 = monoeg_g_strdup_printf ("Invalid method row %d invalid MemberAccessMask 0x7", i);
        vinfo->info.message = D.20956;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.20957 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.20957;
      }
      <D.20955>:
      ctx->valid = 0;
      return;
      <D.20953>:
      D.20960 = data[3];
      if (D.20960 == 0) goto <D.20958>; else goto <D.20961>;
      <D.20961>:
      D.20960 = data[3];
      D.20962 = is_valid_non_empty_string (ctx, D.20960);
      if (D.20962 == 0) goto <D.20958>; else goto <D.20959>;
      <D.20958>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.20963>; else goto <D.20964>;
      <D.20963>:
      {
        struct MonoVerifyInfoExtended * vinfo;

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

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

          __s2 = name;
          D.20970 = ".ctor";
          D.20971 = MEM[(const unsigned char *)D.20970];
          D.20972 = (int) D.20971;
          D.20973 = *__s2;
          D.20974 = (int) D.20973;
          __result = D.20972 - D.20974;
          {
            if (__s1_len != 0) goto <D.20975>; else goto <D.20976>;
            <D.20975>:
            if (__result == 0) goto <D.20977>; else goto <D.20978>;
            <D.20977>:
            D.20979 = &MEM[(void *)".ctor" + 1B];
            D.20980 = *D.20979;
            D.20981 = (int) D.20980;
            D.20982 = __s2 + 1;
            D.20983 = *D.20982;
            D.20984 = (int) D.20983;
            __result = D.20981 - D.20984;
            if (__s1_len > 1) goto <D.20985>; else goto <D.20986>;
            <D.20985>:
            if (__result == 0) goto <D.20987>; else goto <D.20988>;
            <D.20987>:
            D.20989 = &MEM[(void *)".ctor" + 2B];
            D.20990 = *D.20989;
            D.20991 = (int) D.20990;
            D.20992 = __s2 + 2;
            D.20993 = *D.20992;
            D.20994 = (int) D.20993;
            __result = D.20991 - D.20994;
            if (__s1_len > 2) goto <D.20995>; else goto <D.20996>;
            <D.20995>:
            if (__result == 0) goto <D.20997>; else goto <D.20998>;
            <D.20997>:
            D.20999 = &MEM[(void *)".ctor" + 3B];
            D.21000 = *D.20999;
            D.21001 = (int) D.21000;
            D.21002 = __s2 + 3;
            D.21003 = *D.21002;
            D.21004 = (int) D.21003;
            __result = D.21001 - D.21004;
            <D.20998>:
            <D.20996>:
            <D.20988>:
            <D.20986>:
            <D.20978>:
            <D.20976>:
          }
          D.18457 = __result;
        }
        iftmp.42 = D.18457;
        goto <D.21005>;
        <D.20969>:
        iftmp.42 = __builtin_strcmp (".ctor", name);
        <D.21005>:
        D.18461 = iftmp.42;
      }
      D.21006 = D.18461 == 0;
      is_ctor = (gboolean) D.21006;
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = name;
          D.21010 = ".cctor";
          D.21011 = MEM[(const unsigned char *)D.21010];
          D.21012 = (int) D.21011;
          D.21013 = *__s2;
          D.21014 = (int) D.21013;
          __result = D.21012 - D.21014;
          {
            if (__s1_len != 0) goto <D.21015>; else goto <D.21016>;
            <D.21015>:
            if (__result == 0) goto <D.21017>; else goto <D.21018>;
            <D.21017>:
            D.21019 = &MEM[(void *)".cctor" + 1B];
            D.21020 = *D.21019;
            D.21021 = (int) D.21020;
            D.21022 = __s2 + 1;
            D.21023 = *D.21022;
            D.21024 = (int) D.21023;
            __result = D.21021 - D.21024;
            if (__s1_len > 1) goto <D.21025>; else goto <D.21026>;
            <D.21025>:
            if (__result == 0) goto <D.21027>; else goto <D.21028>;
            <D.21027>:
            D.21029 = &MEM[(void *)".cctor" + 2B];
            D.21030 = *D.21029;
            D.21031 = (int) D.21030;
            D.21032 = __s2 + 2;
            D.21033 = *D.21032;
            D.21034 = (int) D.21033;
            __result = D.21031 - D.21034;
            if (__s1_len > 2) goto <D.21035>; else goto <D.21036>;
            <D.21035>:
            if (__result == 0) goto <D.21037>; else goto <D.21038>;
            <D.21037>:
            D.21039 = &MEM[(void *)".cctor" + 3B];
            D.21040 = *D.21039;
            D.21041 = (int) D.21040;
            D.21042 = __s2 + 3;
            D.21043 = *D.21042;
            D.21044 = (int) D.21043;
            __result = D.21041 - D.21044;
            <D.21038>:
            <D.21036>:
            <D.21028>:
            <D.21026>:
            <D.21018>:
            <D.21016>:
          }
          D.18466 = __result;
        }
        iftmp.43 = D.18466;
        goto <D.21045>;
        <D.21009>:
        iftmp.43 = __builtin_strcmp (".cctor", name);
        <D.21045>:
        D.18470 = iftmp.43;
      }
      D.21046 = D.18470 == 0;
      is_cctor = (gboolean) D.21046;
      if (is_ctor != 0) goto <D.21047>; else goto <D.21049>;
      <D.21049>:
      if (is_cctor != 0) goto <D.21047>; else goto <D.21048>;
      <D.21047>:
      i.44 = (unsigned int) i;
      D.21051 = make_coded_token (78, 6, i.44);
      D.21052 = search_sorted_table (ctx, 42, 2, D.21051);
      if (D.21052 != -1) goto <D.21053>; else goto <D.21054>;
      <D.21053>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21055>; else goto <D.21056>;
      <D.21055>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21057 = monoeg_g_strdup_printf ("Invalid method row %d .ctor or .cctor has generic param", i);
        vinfo->info.message = D.21057;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21058 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21058;
      }
      <D.21056>:
      ctx->valid = 0;
      return;
      <D.21054>:
      <D.21048>:
      D.21059 = flags & 16;
      if (D.21059 != 0) goto <D.21060>; else goto <D.21061>;
      <D.21060>:
      D.21062 = flags & 352;
      if (D.21062 != 0) goto <D.21063>; else goto <D.21064>;
      <D.21063>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21065>; else goto <D.21066>;
      <D.21065>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21067 = monoeg_g_strdup_printf ("Invalid method row %d is static and (final, virtual or new slot)", i);
        vinfo->info.message = D.21067;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21068 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21068;
      }
      <D.21066>:
      ctx->valid = 0;
      return;
      <D.21064>:
      <D.21061>:
      D.21069 = flags & 1024;
      if (D.21069 != 0) goto <D.21070>; else goto <D.21071>;
      <D.21070>:
      D.21072 = flags & 8192;
      if (D.21072 != 0) goto <D.21073>; else goto <D.21074>;
      <D.21073>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21075>; else goto <D.21076>;
      <D.21075>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21077 = monoeg_g_strdup_printf ("Invalid method row %d is Abstract and PinvokeImpl", i);
        vinfo->info.message = D.21077;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21078 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21078;
      }
      <D.21076>:
      ctx->valid = 0;
      return;
      <D.21074>:
      D.21079 = flags & 32;
      if (D.21079 != 0) goto <D.21080>; else goto <D.21081>;
      <D.21080>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21082>; else goto <D.21083>;
      <D.21082>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21084 = monoeg_g_strdup_printf ("Invalid method row %d is Abstract and Final", i);
        vinfo->info.message = D.21084;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21085 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21085;
      }
      <D.21083>:
      ctx->valid = 0;
      return;
      <D.21081>:
      D.21086 = flags & 64;
      if (D.21086 == 0) goto <D.21087>; else goto <D.21088>;
      <D.21087>:
      D.20946 = ctx->report_error;
      if (D.20946 != 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 Abstract but not Virtual", i);
        vinfo->info.message = D.21091;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21092 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21092;
      }
      <D.21090>:
      ctx->valid = 0;
      return;
      <D.21088>:
      <D.21071>:
      if (access == 0) goto <D.21093>; else goto <D.21094>;
      <D.21093>:
      D.21095 = flags & 6144;
      if (D.21095 != 0) goto <D.21096>; else goto <D.21097>;
      <D.21096>:
      D.21098 = ctx->report_warning;
      if (D.21098 != 0) goto <D.21099>; else goto <D.21100>;
      <D.21099>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 2;
        D.21101 = monoeg_g_strdup_printf ("Invalid method row %d is CompileControlled and SpecialName or RtSpecialName", i);
        vinfo->info.message = D.21101;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21102 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21102;
      }
      ctx->valid = 0;
      return;
      <D.21100>:
      <D.21097>:
      <D.21094>:
      D.21103 = flags & 6144;
      if (D.21103 == 4096) goto <D.21104>; else goto <D.21105>;
      <D.21104>:
      D.20946 = ctx->report_error;
      if (D.20946 != 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 RTSpecialName but not SpecialName", i);
        vinfo->info.message = D.21108;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21109 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21109;
      }
      <D.21107>:
      ctx->valid = 0;
      return;
      <D.21105>:
      D.21110 = i + 1;
      D.21111 = (unsigned int) D.21110;
      if (D.21111 < module_method_list) goto <D.21112>; else goto <D.21113>;
      <D.21112>:
      D.21059 = flags & 16;
      if (D.21059 == 0) goto <D.21114>; else goto <D.21115>;
      <D.21114>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21116>; else goto <D.21117>;
      <D.21116>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21118 = monoeg_g_strdup_printf ("Invalid method row %d is a global method but not Static", i);
        vinfo->info.message = D.21118;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21119 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21119;
      }
      <D.21117>:
      ctx->valid = 0;
      return;
      <D.21115>:
      D.21120 = flags & 1088;
      if (D.21120 != 0) goto <D.21121>; else goto <D.21122>;
      <D.21121>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21123>; else goto <D.21124>;
      <D.21123>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21125 = monoeg_g_strdup_printf ("Invalid method row %d is a global method but is Abstract or Virtual", i);
        vinfo->info.message = D.21125;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21126 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21126;
      }
      <D.21124>:
      ctx->valid = 0;
      return;
      <D.21122>:
      if (access == 4) goto <D.21127>; else goto <D.21129>;
      <D.21129>:
      if (access == 2) goto <D.21127>; else goto <D.21130>;
      <D.21130>:
      if (access == 5) goto <D.21127>; else goto <D.21128>;
      <D.21127>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21131>; else goto <D.21132>;
      <D.21131>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21133 = monoeg_g_strdup_printf ("Invalid method row %d is a global method but not CompilerControled, Public, Private or Assembly", i);
        vinfo->info.message = D.21133;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21134 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21134;
      }
      <D.21132>:
      ctx->valid = 0;
      return;
      <D.21128>:
      <D.21113>:
      D.21135 = flags & 800;
      if (D.21135 != 0) goto <D.21136>; else goto <D.21137>;
      <D.21136>:
      D.21086 = flags & 64;
      if (D.21086 == 0) goto <D.21138>; else goto <D.21139>;
      <D.21138>:
      D.20946 = ctx->report_error;
      if (D.20946 != 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 (Final, NewSlot or Strict) but not Virtual", i);
        vinfo->info.message = D.21142;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21143 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21143;
      }
      <D.21141>:
      ctx->valid = 0;
      return;
      <D.21139>:
      <D.21137>:
      D.21072 = flags & 8192;
      if (D.21072 != 0) goto <D.21144>; else goto <D.21145>;
      <D.21144>:
      D.21086 = flags & 64;
      if (D.21086 != 0) goto <D.21146>; else goto <D.21147>;
      <D.21146>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21148>; else goto <D.21149>;
      <D.21148>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21150 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl and Virtual", i);
        vinfo->info.message = D.21150;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21151 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21151;
      }
      <D.21149>:
      ctx->valid = 0;
      return;
      <D.21147>:
      D.21059 = flags & 16;
      if (D.21059 == 0) goto <D.21152>; else goto <D.21153>;
      <D.21152>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21154>; else goto <D.21155>;
      <D.21154>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21156 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl but not Static", i);
        vinfo->info.message = D.21156;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21157 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21157;
      }
      <D.21155>:
      ctx->valid = 0;
      return;
      <D.21153>:
      <D.21145>:
      D.21069 = flags & 1024;
      if (D.21069 == 0) goto <D.21158>; else goto <D.21159>;
      <D.21158>:
      if (rva == 0) goto <D.21160>; else goto <D.21161>;
      <D.21160>:
      D.21072 = flags & 8192;
      if (D.21072 == 0) goto <D.21162>; else goto <D.21163>;
      <D.21162>:
      D.21164 = implflags & 4096;
      if (D.21164 == 0) goto <D.21165>; else goto <D.21166>;
      <D.21165>:
      if (code_type != 3) goto <D.21167>; else goto <D.21168>;
      <D.21167>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21169>; else goto <D.21170>;
      <D.21169>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21171 = 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.21171;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21172 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21172;
      }
      <D.21170>:
      ctx->valid = 0;
      return;
      <D.21168>:
      <D.21166>:
      <D.21163>:
      <D.21161>:
      <D.21159>:
      if (access == 0) goto <D.21173>; else goto <D.21174>;
      <D.21173>:
      if (rva == 0) goto <D.21175>; else goto <D.21176>;
      <D.21175>:
      D.21072 = flags & 8192;
      if (D.21072 == 0) goto <D.21177>; else goto <D.21178>;
      <D.21177>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21179>; else goto <D.21180>;
      <D.21179>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21181 = monoeg_g_strdup_printf ("Invalid method row %d is CompilerControlled but neither RVA != 0 or PinvokeImpl", i);
        vinfo->info.message = D.21181;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21182 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21182;
      }
      <D.21180>:
      ctx->valid = 0;
      return;
      <D.21178>:
      <D.21176>:
      <D.21174>:
      if (rva != 0) goto <D.21183>; else goto <D.21184>;
      <D.21183>:
      D.21187 = flags & 9216;
      if (D.21187 != 0) goto <D.21185>; else goto <D.21188>;
      <D.21188>:
      D.21164 = implflags & 4096;
      if (D.21164 != 0) goto <D.21185>; else goto <D.21186>;
      <D.21185>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21189>; else goto <D.21190>;
      <D.21189>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21191 = monoeg_g_strdup_printf ("Invalid method row %d has RVA != 0 but is either Abstract, InternalCall or PinvokeImpl", i);
        vinfo->info.message = D.21191;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21192 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21192;
      }
      <D.21190>:
      ctx->valid = 0;
      return;
      <D.21186>:
      if (code_type == 2) goto <D.21193>; else goto <D.21194>;
      <D.21193>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21195>; else goto <D.21196>;
      <D.21195>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21197 = 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.21197;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21198 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21198;
      }
      <D.21196>:
      ctx->valid = 0;
      return;
      <D.21194>:
      goto <D.21199>;
      <D.21184>:
      D.21187 = flags & 9216;
      if (D.21187 == 0) goto <D.21200>; else goto <D.21201>;
      <D.21200>:
      D.21164 = implflags & 4096;
      if (D.21164 == 0) goto <D.21202>; else goto <D.21203>;
      <D.21202>:
      if (code_type != 3) goto <D.21204>; else goto <D.21205>;
      <D.21204>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21206>; else goto <D.21207>;
      <D.21206>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21208 = monoeg_g_strdup_printf ("Invalid method row %d has RVA = 0 but neither Abstract, InternalCall, Runtime or PinvokeImpl", i);
        vinfo->info.message = D.21208;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21209 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21209;
      }
      <D.21207>:
      ctx->valid = 0;
      return;
      <D.21205>:
      <D.21203>:
      <D.21201>:
      <D.21199>:
      D.21072 = flags & 8192;
      if (D.21072 != 0) goto <D.21210>; else goto <D.21211>;
      <D.21210>:
      if (rva != 0) goto <D.21212>; else goto <D.21213>;
      <D.21212>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21214>; else goto <D.21215>;
      <D.21214>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21216 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl but has RVA != 0", i);
        vinfo->info.message = D.21216;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21217 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21217;
      }
      <D.21215>:
      ctx->valid = 0;
      return;
      <D.21213>:
      i.44 = (unsigned int) i;
      D.21218 = make_coded_token (56, 6, i.44);
      D.21219 = search_sorted_table (ctx, 28, 1, D.21218);
      if (D.21219 == -1) goto <D.21220>; else goto <D.21221>;
      <D.21220>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21222>; else goto <D.21223>;
      <D.21222>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21224 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl but has no row in the ImplMap table", i);
        vinfo->info.message = D.21224;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21225 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21225;
      }
      <D.21223>:
      ctx->valid = 0;
      return;
      <D.21221>:
      <D.21211>:
      D.21226 = flags & 4096;
      if (D.21226 != 0) goto <D.21227>; else goto <D.21228>;
      <D.21227>:
      if (is_ctor == 0) goto <D.21229>; else goto <D.21230>;
      <D.21229>:
      if (is_cctor == 0) goto <D.21231>; else goto <D.21232>;
      <D.21231>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21233>; else goto <D.21234>;
      <D.21233>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21235 = monoeg_g_strdup_printf ("Invalid method row %d is RtSpecialName but not named .ctor or .cctor", i);
        vinfo->info.message = D.21235;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21236 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21236;
      }
      <D.21234>:
      ctx->valid = 0;
      return;
      <D.21232>:
      <D.21230>:
      <D.21228>:
      if (is_ctor != 0) goto <D.21237>; else goto <D.21239>;
      <D.21239>:
      if (is_cctor != 0) goto <D.21237>; else goto <D.21238>;
      <D.21237>:
      D.21226 = flags & 4096;
      if (D.21226 == 0) goto <D.21240>; else goto <D.21241>;
      <D.21240>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21242>; else goto <D.21243>;
      <D.21242>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21244 = monoeg_g_strdup_printf ("Invalid method row %d is named .ctor or .cctor but is not RtSpecialName", i);
        vinfo->info.message = D.21244;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21245 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21245;
      }
      <D.21243>:
      ctx->valid = 0;
      return;
      <D.21241>:
      <D.21238>:
      D.21246 = data[4];
      if (D.21246 != 0) goto <D.21247>; else goto <D.21248>;
      <D.21247>:
      D.21246 = data[4];
      D.21249 = is_valid_blob_object (ctx, D.21246, 1);
      if (D.21249 == 0) goto <D.21250>; else goto <D.21251>;
      <D.21250>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21252>; else goto <D.21253>;
      <D.21252>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21246 = data[4];
        D.21254 = monoeg_g_strdup_printf ("Invalid method row %d invalid signature blob token 0x%x", i, D.21246);
        vinfo->info.message = D.21254;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21255 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21255;
      }
      <D.21253>:
      ctx->valid = 0;
      return;
      <D.21251>:
      <D.21248>:
      D.21256 = data[5];
      if (D.21256 == 0) goto <D.21257>; else goto <D.21258>;
      <D.21257>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21259>; else goto <D.21260>;
      <D.21259>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21261 = monoeg_g_strdup_printf ("Invalid method row %d ParamList be be >= 1", i);
        vinfo->info.message = D.21261;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21262 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21262;
      }
      <D.21260>:
      ctx->valid = 0;
      return;
      <D.21258>:
      D.21256 = data[5];
      if (D.21256 < paramlist) goto <D.21263>; else goto <D.21264>;
      <D.21263>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21265>; else goto <D.21266>;
      <D.21265>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21256 = data[5];
        D.21267 = monoeg_g_strdup_printf ("Invalid method row %d ParamList rowid 0x%08x can\'t be smaller than of previous row 0x%08x", i, D.21256, paramlist);
        vinfo->info.message = D.21267;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21268 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21268;
      }
      <D.21266>:
      ctx->valid = 0;
      return;
      <D.21264>:
      D.21256 = data[5];
      D.20938 = ctx->image;
      D.21269 = D.20938->tables[8].rows;
      D.21270 = (int) D.21269;
      D.21271 = D.21270 + 1;
      D.21272 = (unsigned int) D.21271;
      if (D.21256 > D.21272) goto <D.21273>; else goto <D.21274>;
      <D.21273>:
      D.20946 = ctx->report_error;
      if (D.20946 != 0) goto <D.21275>; else goto <D.21276>;
      <D.21275>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21256 = data[5];
        D.21277 = monoeg_g_strdup_printf ("Invalid method row %d ParamList rowid 0x%08x is out of range", i, D.21256);
        vinfo->info.message = D.21277;
        vinfo->exception_type = 3;
        D.20950 = ctx->errors;
        D.21278 = monoeg_g_slist_prepend (D.20950, vinfo);
        ctx->errors = D.21278;
      }
      <D.21276>:
      ctx->valid = 0;
      return;
      <D.21274>:
      paramlist = data[5];
      i = i + 1;
      <D.18498>:
      D.21279 = table->rows;
      D.21280 = (int) D.21279;
      if (D.21280 > i) goto <D.18497>; else goto <D.18499>;
      <D.18499>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


get_string_ptr (struct VerifyContext * ctx, guint offset)
{
  const char * D.21284;
  struct MonoImage * D.21285;
  const char * D.21286;

  D.21285 = ctx->image;
  D.21286 = D.21285->heap_strings.data;
  D.21284 = D.21286 + offset;
  return D.21284;
}


verify_param_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21288;
  unsigned int D.21289;
  unsigned int D.21290;
  <unnamed-unsigned:24> D.21293;
  int D.21294;
  int D.21297;
  gchar * D.21300;
  struct GSList * D.21301;
  struct GSList * D.21302;
  unsigned int D.21303;
  gchar * D.21308;
  struct GSList * D.21309;
  unsigned int i.45;
  unsigned int D.21311;
  int D.21312;
  unsigned int D.21315;
  gchar * D.21320;
  struct GSList * D.21321;
  gchar * D.21327;
  struct GSList * D.21328;
  unsigned int D.21329;
  unsigned int D.21332;
  int D.21333;
  gchar * D.21338;
  struct GSList * D.21339;
  unsigned int D.21340;
  int D.21341;
  gchar * D.21346;
  struct GSList * D.21347;
  unsigned int D.21350;
  gchar * D.21355;
  struct GSList * D.21356;
  struct MonoTableInfo * table;
  guint32 data[3];
  guint32 flags;
  guint32 sequence;
  guint32 remaining_params;
  guint32 current_method;
  gboolean first_param;
  int i;

  try
    {
      D.21288 = ctx->image;
      table = &D.21288->tables[8];
      sequence = 0;
      current_method = 0;
      first_param = 1;
      D.21288 = ctx->image;
      D.21289 = BIT_FIELD_REF <*D.21288, 32, 1408>;
      D.21290 = D.21289 & 16777215;
      if (D.21290 == 0) goto <D.21291>; else goto <D.21292>;
      <D.21291>:
      D.21293 = table->rows;
      D.21294 = (int) D.21293;
      if (D.21294 > 0) goto <D.21295>; else goto <D.21296>;
      <D.21295>:
      D.21297 = ctx->report_error;
      if (D.21297 != 0) goto <D.21298>; else goto <D.21299>;
      <D.21298>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21300 = monoeg_strdup ("Param table has rows while the method table has zero");
        vinfo->info.message = D.21300;
        vinfo->exception_type = 3;
        D.21301 = ctx->errors;
        D.21302 = monoeg_g_slist_prepend (D.21301, vinfo);
        ctx->errors = D.21302;
      }
      <D.21299>:
      ctx->valid = 0;
      return;
      <D.21296>:
      return;
      <D.21292>:
      remaining_params = get_next_param_count (ctx, &current_method);
      i = 0;
      goto <D.18543>;
      <D.18542>:
      mono_metadata_decode_row (table, i, &data, 3);
      flags = data[0];
      D.21303 = flags & 53228;
      if (D.21303 != 0) goto <D.21304>; else goto <D.21305>;
      <D.21304>:
      D.21297 = ctx->report_error;
      if (D.21297 != 0) goto <D.21306>; else goto <D.21307>;
      <D.21306>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21308 = monoeg_g_strdup_printf ("Invalid param row %d bad Flags value 0x%08x", i, flags);
        vinfo->info.message = D.21308;
        vinfo->exception_type = 3;
        D.21301 = ctx->errors;
        D.21309 = monoeg_g_slist_prepend (D.21301, vinfo);
        ctx->errors = D.21309;
      }
      <D.21307>:
      ctx->valid = 0;
      return;
      <D.21305>:
      i.45 = (unsigned int) i;
      D.21311 = make_coded_token (5, 8, i.45);
      D.21312 = search_sorted_table (ctx, 11, 2, D.21311);
      if (D.21312 == -1) goto <D.21313>; else goto <D.21314>;
      <D.21313>:
      D.21315 = flags & 4096;
      if (D.21315 != 0) goto <D.21316>; else goto <D.21317>;
      <D.21316>:
      D.21297 = ctx->report_error;
      if (D.21297 != 0) goto <D.21318>; else goto <D.21319>;
      <D.21318>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21320 = monoeg_g_strdup_printf ("Invalid param row %d HasDefault = 1 but no owned row in Contant table", i);
        vinfo->info.message = D.21320;
        vinfo->exception_type = 3;
        D.21301 = ctx->errors;
        D.21321 = monoeg_g_slist_prepend (D.21301, vinfo);
        ctx->errors = D.21321;
      }
      <D.21319>:
      ctx->valid = 0;
      return;
      <D.21317>:
      goto <D.21322>;
      <D.21314>:
      D.21315 = flags & 4096;
      if (D.21315 == 0) goto <D.21323>; else goto <D.21324>;
      <D.21323>:
      D.21297 = ctx->report_error;
      if (D.21297 != 0) goto <D.21325>; else goto <D.21326>;
      <D.21325>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21327 = monoeg_g_strdup_printf ("Invalid param row %d HasDefault = 0 but has owned row in Contant table", i);
        vinfo->info.message = D.21327;
        vinfo->exception_type = 3;
        D.21301 = ctx->errors;
        D.21328 = monoeg_g_slist_prepend (D.21301, vinfo);
        ctx->errors = D.21328;
      }
      <D.21326>:
      ctx->valid = 0;
      return;
      <D.21324>:
      <D.21322>:
      D.21329 = flags & 8192;
      if (D.21329 != 0) goto <D.21330>; else goto <D.21331>;
      <D.21330>:
      i.45 = (unsigned int) i;
      D.21332 = make_coded_token (32, 8, i.45);
      D.21333 = search_sorted_table (ctx, 13, 0, D.21332);
      if (D.21333 == -1) goto <D.21334>; else goto <D.21335>;
      <D.21334>:
      D.21297 = ctx->report_error;
      if (D.21297 != 0) goto <D.21336>; else goto <D.21337>;
      <D.21336>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21338 = monoeg_g_strdup_printf ("Invalid param row %d HasFieldMarshal = 1 but no owned row in FieldMarshal table", i);
        vinfo->info.message = D.21338;
        vinfo->exception_type = 3;
        D.21301 = ctx->errors;
        D.21339 = monoeg_g_slist_prepend (D.21301, vinfo);
        ctx->errors = D.21339;
      }
      <D.21337>:
      ctx->valid = 0;
      return;
      <D.21335>:
      <D.21331>:
      D.21340 = data[2];
      D.21341 = is_valid_string (ctx, D.21340);
      if (D.21341 == 0) goto <D.21342>; else goto <D.21343>;
      <D.21342>:
      D.21297 = ctx->report_error;
      if (D.21297 != 0) goto <D.21344>; else goto <D.21345>;
      <D.21344>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21340 = data[2];
        D.21346 = monoeg_g_strdup_printf ("Invalid param row %d Name = 1 bad token 0x%08x", i, D.21340);
        vinfo->info.message = D.21346;
        vinfo->exception_type = 3;
        D.21301 = ctx->errors;
        D.21347 = monoeg_g_slist_prepend (D.21301, vinfo);
        ctx->errors = D.21347;
      }
      <D.21345>:
      ctx->valid = 0;
      return;
      <D.21343>:
      if (first_param == 0) goto <D.21348>; else goto <D.21349>;
      <D.21348>:
      D.21350 = data[1];
      if (D.21350 <= sequence) goto <D.21351>; else goto <D.21352>;
      <D.21351>:
      D.21297 = ctx->report_error;
      if (D.21297 != 0) goto <D.21353>; else goto <D.21354>;
      <D.21353>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21350 = data[1];
        D.21355 = monoeg_g_strdup_printf ("Invalid param row %d sequece = %d previus param has %d", i, D.21350, sequence);
        vinfo->info.message = D.21355;
        vinfo->exception_type = 3;
        D.21301 = ctx->errors;
        D.21356 = monoeg_g_slist_prepend (D.21301, vinfo);
        ctx->errors = D.21356;
      }
      <D.21354>:
      ctx->valid = 0;
      return;
      <D.21352>:
      <D.21349>:
      first_param = 0;
      sequence = data[1];
      remaining_params = remaining_params + 4294967295;
      if (remaining_params == 0) goto <D.21357>; else goto <D.21358>;
      <D.21357>:
      remaining_params = get_next_param_count (ctx, &current_method);
      first_param = 1;
      <D.21358>:
      i = i + 1;
      <D.18543>:
      D.21293 = table->rows;
      D.21294 = (int) D.21293;
      if (D.21294 > i) goto <D.18542>; else goto <D.18544>;
      <D.18544>:
    }
  finally
    {
      data = {CLOBBER};
      current_method = {CLOBBER};
    }
}


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

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


get_next_param_count (struct VerifyContext * ctx, guint32 * current_method)
{
  struct MonoImage * D.21364;
  unsigned int row.46;
  int row.47;
  int row.48;
  guint32 D.21370;
  <unnamed-unsigned:24> D.21371;
  unsigned int D.21372;
  struct MonoTableInfo * table;
  guint32 row;
  guint32 paramlist;
  guint32 tmp;

  D.21364 = ctx->image;
  table = &D.21364->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.18522>;
  <D.18521>:
  row.48 = (int) row;
  tmp = mono_metadata_decode_row_col (table, row.48, 5);
  if (tmp > paramlist) goto <D.21368>; else goto <D.21369>;
  <D.21368>:
  *current_method = row;
  D.21370 = tmp - paramlist;
  return D.21370;
  <D.21369>:
  row = row + 1;
  <D.18522>:
  D.21371 = table->rows;
  D.21372 = (unsigned int) D.21371;
  if (D.21372 > row) goto <D.18521>; else goto <D.18523>;
  <D.18523>:
  D.21371 = table->rows;
  D.21372 = (unsigned int) D.21371;
  *current_method = D.21372;
  D.21370 = 4294967295;
  return D.21370;
}


verify_interfaceimpl_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21374;
  unsigned int D.21375;
  <unnamed-unsigned:24> D.21378;
  unsigned int D.21379;
  int D.21382;
  gchar * D.21385;
  struct GSList * D.21386;
  struct GSList * D.21387;
  unsigned int D.21388;
  int D.21389;
  gchar * D.21394;
  struct GSList * D.21395;
  unsigned int D.21396;
  gchar * D.21401;
  struct GSList * D.21402;
  <unnamed-unsigned:24> D.21403;
  int D.21404;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.21374 = ctx->image;
      table = &D.21374->tables[9];
      i = 0;
      goto <D.18555>;
      <D.18554>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.21375 = data[0];
      if (D.21375 != 0) goto <D.21376>; else goto <D.21377>;
      <D.21376>:
      D.21375 = data[0];
      D.21374 = ctx->image;
      D.21378 = D.21374->tables[2].rows;
      D.21379 = (unsigned int) D.21378;
      if (D.21375 > D.21379) goto <D.21380>; else goto <D.21381>;
      <D.21380>:
      D.21382 = ctx->report_error;
      if (D.21382 != 0) goto <D.21383>; else goto <D.21384>;
      <D.21383>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21375 = data[0];
        D.21385 = monoeg_g_strdup_printf ("Invalid InterfaceImpl row %d Class field 0x%08x", i, D.21375);
        vinfo->info.message = D.21385;
        vinfo->exception_type = 3;
        D.21386 = ctx->errors;
        D.21387 = monoeg_g_slist_prepend (D.21386, vinfo);
        ctx->errors = D.21387;
      }
      <D.21384>:
      ctx->valid = 0;
      return;
      <D.21381>:
      <D.21377>:
      D.21388 = data[1];
      D.21389 = is_valid_coded_index (ctx, 0, D.21388);
      if (D.21389 == 0) goto <D.21390>; else goto <D.21391>;
      <D.21390>:
      D.21382 = ctx->report_error;
      if (D.21382 != 0) goto <D.21392>; else goto <D.21393>;
      <D.21392>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21388 = data[1];
        D.21394 = monoeg_g_strdup_printf ("Invalid InterfaceImpl row %d Inteface field coded index 0x%08x", i, D.21388);
        vinfo->info.message = D.21394;
        vinfo->exception_type = 3;
        D.21386 = ctx->errors;
        D.21395 = monoeg_g_slist_prepend (D.21386, vinfo);
        ctx->errors = D.21395;
      }
      <D.21393>:
      ctx->valid = 0;
      return;
      <D.21391>:
      D.21388 = data[1];
      D.21396 = get_coded_index_token (0, D.21388);
      if (D.21396 == 0) goto <D.21397>; else goto <D.21398>;
      <D.21397>:
      D.21382 = ctx->report_error;
      if (D.21382 != 0) goto <D.21399>; else goto <D.21400>;
      <D.21399>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21401 = monoeg_g_strdup_printf ("Invalid InterfaceImpl row %d Inteface field is null", i);
        vinfo->info.message = D.21401;
        vinfo->exception_type = 3;
        D.21386 = ctx->errors;
        D.21402 = monoeg_g_slist_prepend (D.21386, vinfo);
        ctx->errors = D.21402;
      }
      <D.21400>:
      ctx->valid = 0;
      return;
      <D.21398>:
      i = i + 1;
      <D.18555>:
      D.21403 = table->rows;
      D.21404 = (int) D.21403;
      if (D.21404 > i) goto <D.18554>; else goto <D.18556>;
      <D.18556>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_memberref_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21408;
  unsigned int D.21409;
  int D.21410;
  int D.21413;
  gchar * D.21416;
  struct GSList * D.21417;
  struct GSList * D.21418;
  unsigned int D.21419;
  gchar * D.21424;
  struct GSList * D.21425;
  unsigned int D.21426;
  int D.21427;
  gchar * D.21432;
  struct GSList * D.21433;
  unsigned int D.21434;
  int D.21437;
  gchar * D.21442;
  struct GSList * D.21443;
  <unnamed-unsigned:24> D.21444;
  int D.21445;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.21408 = ctx->image;
      table = &D.21408->tables[10];
      i = 0;
      goto <D.18568>;
      <D.18567>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.21409 = data[0];
      D.21410 = is_valid_coded_index (ctx, 41, D.21409);
      if (D.21410 == 0) goto <D.21411>; else goto <D.21412>;
      <D.21411>:
      D.21413 = ctx->report_error;
      if (D.21413 != 0) goto <D.21414>; else goto <D.21415>;
      <D.21414>:
      {
        struct MonoVerifyInfoExtended * vinfo;

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

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21424 = monoeg_g_strdup_printf ("Invalid MemberRef row %d Class field coded is null", i);
        vinfo->info.message = D.21424;
        vinfo->exception_type = 3;
        D.21417 = ctx->errors;
        D.21425 = monoeg_g_slist_prepend (D.21417, vinfo);
        ctx->errors = D.21425;
      }
      <D.21423>:
      ctx->valid = 0;
      return;
      <D.21421>:
      D.21426 = data[1];
      D.21427 = is_valid_non_empty_string (ctx, D.21426);
      if (D.21427 == 0) goto <D.21428>; else goto <D.21429>;
      <D.21428>:
      D.21413 = ctx->report_error;
      if (D.21413 != 0) goto <D.21430>; else goto <D.21431>;
      <D.21430>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21426 = data[1];
        D.21432 = monoeg_g_strdup_printf ("Invalid MemberRef row %d Name field coded is invalid or empty 0x%08x", i, D.21426);
        vinfo->info.message = D.21432;
        vinfo->exception_type = 3;
        D.21417 = ctx->errors;
        D.21433 = monoeg_g_slist_prepend (D.21417, vinfo);
        ctx->errors = D.21433;
      }
      <D.21431>:
      ctx->valid = 0;
      return;
      <D.21429>:
      D.21434 = data[2];
      if (D.21434 != 0) goto <D.21435>; else goto <D.21436>;
      <D.21435>:
      D.21434 = data[2];
      D.21437 = is_valid_blob_object (ctx, D.21434, 1);
      if (D.21437 == 0) goto <D.21438>; else goto <D.21439>;
      <D.21438>:
      D.21413 = ctx->report_error;
      if (D.21413 != 0) goto <D.21440>; else goto <D.21441>;
      <D.21440>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21434 = data[2];
        D.21442 = monoeg_g_strdup_printf ("Invalid MemberRef row %d invalid signature blob token 0x%x", i, D.21434);
        vinfo->info.message = D.21442;
        vinfo->exception_type = 3;
        D.21417 = ctx->errors;
        D.21443 = monoeg_g_slist_prepend (D.21417, vinfo);
        ctx->errors = D.21443;
      }
      <D.21441>:
      ctx->valid = 0;
      return;
      <D.21439>:
      <D.21436>:
      i = i + 1;
      <D.18568>:
      D.21444 = table->rows;
      D.21445 = (int) D.21444;
      if (D.21445 > i) goto <D.18567>; else goto <D.18569>;
      <D.18569>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_constant_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21449;
  unsigned int D.21450;
  int D.21455;
  gchar * D.21458;
  struct GSList * D.21459;
  struct GSList * D.21460;
  unsigned int D.21461;
  int D.21462;
  gchar * D.21467;
  struct GSList * D.21468;
  unsigned int D.21469;
  gchar * D.21474;
  struct GSList * D.21475;
  unsigned int D.21476;
  int D.21477;
  gchar * D.21482;
  struct GSList * D.21483;
  <unnamed-unsigned:24> D.21484;
  int D.21485;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 type;
  int i;

  try
    {
      D.21449 = ctx->image;
      table = &D.21449->tables[11];
      i = 0;
      goto <D.18592>;
      <D.18591>:
      mono_metadata_decode_row (table, i, &data, 4);
      type = data[0];
      D.21450 = type + 4294967294;
      if (D.21450 > 12) goto <D.21451>; else goto <D.21452>;
      <D.21451>:
      if (type != 18) goto <D.21453>; else goto <D.21454>;
      <D.21453>:
      D.21455 = ctx->report_error;
      if (D.21455 != 0) goto <D.21456>; else goto <D.21457>;
      <D.21456>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21458 = monoeg_g_strdup_printf ("Invalid Constant row %d Type field 0x%08x", i, type);
        vinfo->info.message = D.21458;
        vinfo->exception_type = 3;
        D.21459 = ctx->errors;
        D.21460 = monoeg_g_slist_prepend (D.21459, vinfo);
        ctx->errors = D.21460;
      }
      <D.21457>:
      ctx->valid = 0;
      return;
      <D.21454>:
      <D.21452>:
      D.21461 = data[2];
      D.21462 = is_valid_coded_index (ctx, 5, D.21461);
      if (D.21462 == 0) goto <D.21463>; else goto <D.21464>;
      <D.21463>:
      D.21455 = ctx->report_error;
      if (D.21455 != 0) goto <D.21465>; else goto <D.21466>;
      <D.21465>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21461 = data[2];
        D.21467 = monoeg_g_strdup_printf ("Invalid Constant row %d Parent field coded index 0x%08x", i, D.21461);
        vinfo->info.message = D.21467;
        vinfo->exception_type = 3;
        D.21459 = ctx->errors;
        D.21468 = monoeg_g_slist_prepend (D.21459, vinfo);
        ctx->errors = D.21468;
      }
      <D.21466>:
      ctx->valid = 0;
      return;
      <D.21464>:
      D.21461 = data[2];
      D.21469 = get_coded_index_token (5, D.21461);
      if (D.21469 == 0) goto <D.21470>; else goto <D.21471>;
      <D.21470>:
      D.21455 = ctx->report_error;
      if (D.21455 != 0) goto <D.21472>; else goto <D.21473>;
      <D.21472>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21474 = monoeg_g_strdup_printf ("Invalid Constant row %d Parent field coded is null", i);
        vinfo->info.message = D.21474;
        vinfo->exception_type = 3;
        D.21459 = ctx->errors;
        D.21475 = monoeg_g_slist_prepend (D.21459, vinfo);
        ctx->errors = D.21475;
      }
      <D.21473>:
      ctx->valid = 0;
      return;
      <D.21471>:
      D.21476 = data[3];
      D.21477 = is_valid_constant (ctx, type, D.21476);
      if (D.21477 == 0) goto <D.21478>; else goto <D.21479>;
      <D.21478>:
      D.21455 = ctx->report_error;
      if (D.21455 != 0) goto <D.21480>; else goto <D.21481>;
      <D.21480>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21476 = data[3];
        D.21482 = monoeg_g_strdup_printf ("Invalid Constant row %d Value field 0x%08x", i, D.21476);
        vinfo->info.message = D.21482;
        vinfo->exception_type = 3;
        D.21459 = ctx->errors;
        D.21483 = monoeg_g_slist_prepend (D.21459, vinfo);
        ctx->errors = D.21483;
      }
      <D.21481>:
      ctx->valid = 0;
      return;
      <D.21479>:
      i = i + 1;
      <D.18592>:
      D.21484 = table->rows;
      D.21485 = (int) D.21484;
      if (D.21485 > i) goto <D.18591>; else goto <D.18593>;
      <D.18593>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_constant (struct VerifyContext * ctx, guint32 type, guint32 offset)
{
  struct MonoImage * D.21489;
  struct MonoStreamHeader * D.21490;
  unsigned int D.21491;
  int D.21494;
  gchar * D.21497;
  struct GSList * D.21498;
  struct GSList * D.21499;
  gboolean D.21500;
  const char * D.21501;
  unsigned int D.21502;
  sizetype D.21503;
  const char * D.21504;
  unsigned int D.21505;
  int D.21506;
  gchar * D.21511;
  struct GSList * D.21512;
  unsigned int bytes.49;
  unsigned int entry_size.50;
  unsigned int D.21519;
  unsigned int D.21521;
  unsigned int D.21524;
  unsigned int D.21525;
  gchar * D.21526;
  struct GSList * D.21527;
  gchar * D.21532;
  struct GSList * D.21533;
  unsigned int D.21536;
  unsigned int D.21538;
  gchar * D.21541;
  struct GSList * D.21542;
  unsigned int D.21545;
  gchar * D.21550;
  struct GSList * D.21551;
  struct OffsetAndSize blob;
  guint32 size;
  guint32 entry_size;
  guint32 bytes;

  try
    {
      D.21489 = ctx->image;
      D.21490 = &D.21489->heap_blob;
      blob = get_metadata_stream (ctx, D.21490); [return slot optimization]
      D.21491 = blob.size;
      if (D.21491 < offset) goto <D.21492>; else goto <D.21493>;
      <D.21492>:
      D.21494 = ctx->report_error;
      if (D.21494 != 0) goto <D.21495>; else goto <D.21496>;
      <D.21495>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21497 = monoeg_strdup ("ContantValue: invalid offset");
        vinfo->info.message = D.21497;
        vinfo->exception_type = 3;
        D.21498 = ctx->errors;
        D.21499 = monoeg_g_slist_prepend (D.21498, vinfo);
        ctx->errors = D.21499;
      }
      <D.21496>:
      ctx->valid = 0;
      D.21500 = 0;
      return D.21500;
      <D.21493>:
      D.21501 = ctx->data;
      D.21502 = blob.offset;
      D.21503 = D.21502 + offset;
      D.21504 = D.21501 + D.21503;
      D.21491 = blob.size;
      D.21502 = blob.offset;
      D.21505 = D.21491 - D.21502;
      D.21506 = decode_value (D.21504, D.21505, &entry_size, &bytes);
      if (D.21506 == 0) goto <D.21507>; else goto <D.21508>;
      <D.21507>:
      D.21494 = ctx->report_error;
      if (D.21494 != 0) goto <D.21509>; else goto <D.21510>;
      <D.21509>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21511 = monoeg_strdup ("ContantValue: not enough space to decode size");
        vinfo->info.message = D.21511;
        vinfo->exception_type = 3;
        D.21498 = ctx->errors;
        D.21512 = monoeg_g_slist_prepend (D.21498, vinfo);
        ctx->errors = D.21512;
      }
      <D.21510>:
      ctx->valid = 0;
      D.21500 = 0;
      return D.21500;
      <D.21508>:
      if (type == 14) goto <D.21513>; else goto <D.21514>;
      <D.21513>:
      bytes.49 = bytes;
      offset = offset + bytes.49;
      entry_size.50 = entry_size;
      D.21519 = offset + entry_size.50;
      D.21491 = blob.size;
      if (D.21519 > D.21491) goto <D.21516>; else goto <D.21520>;
      <D.21520>:
      entry_size.50 = entry_size;
      D.21521 = ~entry_size.50;
      if (D.21521 < offset) goto <D.21516>; else goto <D.21517>;
      <D.21516>:
      D.21494 = ctx->report_error;
      if (D.21494 != 0) goto <D.21522>; else goto <D.21523>;
      <D.21522>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        entry_size.50 = entry_size;
        D.21524 = entry_size.50 * 2;
        D.21491 = blob.size;
        D.21525 = D.21491 - offset;
        D.21526 = monoeg_g_strdup_printf ("ContantValue: not enough space for string, required %d but got %d", D.21524, D.21525);
        vinfo->info.message = D.21526;
        vinfo->exception_type = 3;
        D.21498 = ctx->errors;
        D.21527 = monoeg_g_slist_prepend (D.21498, vinfo);
        ctx->errors = D.21527;
      }
      <D.21523>:
      ctx->valid = 0;
      D.21500 = 0;
      return D.21500;
      <D.21517>:
      D.21500 = 1;
      return D.21500;
      <D.21514>:
      switch (type) <default: <D.18277>, case 2: <D.18263>, case 3: <D.18267>, case 4: <D.18264>, case 5: <D.18265>, case 6: <D.18268>, case 7: <D.18269>, case 8: <D.18270>, case 9: <D.18271>, case 10: <D.18274>, case 11: <D.18275>, case 12: <D.18272>, case 13: <D.18276>, case 18: <D.18273>>
      <D.18263>:
      <D.18264>:
      <D.18265>:
      size = 1;
      goto <D.18266>;
      <D.18267>:
      <D.18268>:
      <D.18269>:
      size = 2;
      goto <D.18266>;
      <D.18270>:
      <D.18271>:
      <D.18272>:
      <D.18273>:
      size = 4;
      goto <D.18266>;
      <D.18274>:
      <D.18275>:
      <D.18276>:
      size = 8;
      goto <D.18266>;
      <D.18277>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata-verify.c", 2221);
      <D.18266>:
      entry_size.50 = entry_size;
      if (size != entry_size.50) goto <D.21528>; else goto <D.21529>;
      <D.21528>:
      D.21494 = ctx->report_error;
      if (D.21494 != 0) goto <D.21530>; else goto <D.21531>;
      <D.21530>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        entry_size.50 = entry_size;
        D.21532 = monoeg_g_strdup_printf ("ContantValue: Expected size %d but got %d", size, entry_size.50);
        vinfo->info.message = D.21532;
        vinfo->exception_type = 3;
        D.21498 = ctx->errors;
        D.21533 = monoeg_g_slist_prepend (D.21498, vinfo);
        ctx->errors = D.21533;
      }
      <D.21531>:
      ctx->valid = 0;
      D.21500 = 0;
      return D.21500;
      <D.21529>:
      bytes.49 = bytes;
      offset = offset + bytes.49;
      D.21536 = offset + size;
      D.21491 = blob.size;
      if (D.21536 > D.21491) goto <D.21534>; else goto <D.21537>;
      <D.21537>:
      D.21538 = ~size;
      if (D.21538 < offset) goto <D.21534>; else goto <D.21535>;
      <D.21534>:
      D.21494 = ctx->report_error;
      if (D.21494 != 0) goto <D.21539>; else goto <D.21540>;
      <D.21539>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21491 = blob.size;
        D.21525 = D.21491 - offset;
        D.21541 = monoeg_g_strdup_printf ("ContantValue: Not enough room for constant, required %d but have %d", size, D.21525);
        vinfo->info.message = D.21541;
        vinfo->exception_type = 3;
        D.21498 = ctx->errors;
        D.21542 = monoeg_g_slist_prepend (D.21498, vinfo);
        ctx->errors = D.21542;
      }
      <D.21540>:
      ctx->valid = 0;
      D.21500 = 0;
      return D.21500;
      <D.21535>:
      if (type == 18) goto <D.21543>; else goto <D.21544>;
      <D.21543>:
      D.21501 = ctx->data;
      D.21502 = blob.offset;
      D.21503 = D.21502 + offset;
      D.21504 = D.21501 + D.21503;
      D.21545 = mono_read32 (D.21504);
      if (D.21545 != 0) goto <D.21546>; else goto <D.21547>;
      <D.21546>:
      D.21494 = ctx->report_error;
      if (D.21494 != 0) goto <D.21548>; else goto <D.21549>;
      <D.21548>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21550 = monoeg_g_strdup_printf ("ContantValue: Type is class but value is not null");
        vinfo->info.message = D.21550;
        vinfo->exception_type = 3;
        D.21498 = ctx->errors;
        D.21551 = monoeg_g_slist_prepend (D.21498, vinfo);
        ctx->errors = D.21551;
      }
      <D.21549>:
      ctx->valid = 0;
      D.21500 = 0;
      return D.21500;
      <D.21547>:
      <D.21544>:
      D.21500 = 1;
      return D.21500;
    }
  finally
    {
      blob = {CLOBBER};
      entry_size = {CLOBBER};
      bytes = {CLOBBER};
    }
}


verify_cattr_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21554;
  unsigned int D.21555;
  int D.21556;
  int D.21559;
  gchar * D.21562;
  struct GSList * D.21563;
  struct GSList * D.21564;
  unsigned int D.21567;
  int D.21568;
  unsigned int D.21570;
  gchar * D.21573;
  struct GSList * D.21574;
  unsigned int D.21575;
  int D.21578;
  gchar * D.21583;
  struct GSList * D.21584;
  <unnamed-unsigned:24> D.21585;
  int D.21586;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.21554 = ctx->image;
      table = &D.21554->tables[12];
      i = 0;
      goto <D.18604>;
      <D.18603>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.21555 = data[0];
      D.21556 = is_valid_coded_index (ctx, 10, D.21555);
      if (D.21556 == 0) goto <D.21557>; else goto <D.21558>;
      <D.21557>:
      D.21559 = ctx->report_error;
      if (D.21559 != 0) goto <D.21560>; else goto <D.21561>;
      <D.21560>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21555 = data[0];
        D.21562 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d Parent field 0x%08x", i, D.21555);
        vinfo->info.message = D.21562;
        vinfo->exception_type = 3;
        D.21563 = ctx->errors;
        D.21564 = monoeg_g_slist_prepend (D.21563, vinfo);
        ctx->errors = D.21564;
      }
      <D.21561>:
      ctx->valid = 0;
      return;
      <D.21558>:
      D.21567 = data[1];
      D.21568 = is_valid_coded_index (ctx, 65, D.21567);
      if (D.21568 == 0) goto <D.21565>; else goto <D.21569>;
      <D.21569>:
      D.21567 = data[1];
      D.21570 = get_coded_index_token (65, D.21567);
      if (D.21570 == 0) goto <D.21565>; else goto <D.21566>;
      <D.21565>:
      D.21559 = ctx->report_error;
      if (D.21559 != 0) goto <D.21571>; else goto <D.21572>;
      <D.21571>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21567 = data[1];
        D.21573 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d Type field 0x%08x", i, D.21567);
        vinfo->info.message = D.21573;
        vinfo->exception_type = 3;
        D.21563 = ctx->errors;
        D.21574 = monoeg_g_slist_prepend (D.21563, vinfo);
        ctx->errors = D.21574;
      }
      <D.21572>:
      ctx->valid = 0;
      return;
      <D.21566>:
      D.21575 = data[2];
      if (D.21575 != 0) goto <D.21576>; else goto <D.21577>;
      <D.21576>:
      D.21575 = data[2];
      D.21578 = is_valid_blob_object (ctx, D.21575, 0);
      if (D.21578 == 0) goto <D.21579>; else goto <D.21580>;
      <D.21579>:
      D.21559 = ctx->report_error;
      if (D.21559 != 0) goto <D.21581>; else goto <D.21582>;
      <D.21581>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21575 = data[2];
        D.21583 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d invalid value blob 0x%x", i, D.21575);
        vinfo->info.message = D.21583;
        vinfo->exception_type = 3;
        D.21563 = ctx->errors;
        D.21584 = monoeg_g_slist_prepend (D.21563, vinfo);
        ctx->errors = D.21584;
      }
      <D.21582>:
      ctx->valid = 0;
      return;
      <D.21580>:
      <D.21577>:
      i = i + 1;
      <D.18604>:
      D.21585 = table->rows;
      D.21586 = (int) D.21585;
      if (D.21586 > i) goto <D.18603>; else goto <D.18605>;
      <D.18605>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_field_marshal_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21590;
  unsigned int D.21591;
  int D.21592;
  int D.21595;
  gchar * D.21598;
  struct GSList * D.21599;
  struct GSList * D.21600;
  unsigned int D.21601;
  gchar * D.21606;
  struct GSList * D.21607;
  unsigned int D.21608;
  gchar * D.21613;
  struct GSList * D.21614;
  int D.21615;
  gchar * D.21620;
  struct GSList * D.21621;
  <unnamed-unsigned:24> D.21622;
  int D.21623;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.21590 = ctx->image;
      table = &D.21590->tables[13];
      i = 0;
      goto <D.18637>;
      <D.18636>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.21591 = data[0];
      D.21592 = is_valid_coded_index (ctx, 32, D.21591);
      if (D.21592 == 0) goto <D.21593>; else goto <D.21594>;
      <D.21593>:
      D.21595 = ctx->report_error;
      if (D.21595 != 0) goto <D.21596>; else goto <D.21597>;
      <D.21596>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21591 = data[0];
        D.21598 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d Parent field 0x%08x", i, D.21591);
        vinfo->info.message = D.21598;
        vinfo->exception_type = 3;
        D.21599 = ctx->errors;
        D.21600 = monoeg_g_slist_prepend (D.21599, vinfo);
        ctx->errors = D.21600;
      }
      <D.21597>:
      ctx->valid = 0;
      return;
      <D.21594>:
      D.21591 = data[0];
      D.21601 = get_coded_index_token (32, D.21591);
      if (D.21601 == 0) goto <D.21602>; else goto <D.21603>;
      <D.21602>:
      D.21595 = ctx->report_error;
      if (D.21595 != 0) goto <D.21604>; else goto <D.21605>;
      <D.21604>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21606 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d Parent field is null", i);
        vinfo->info.message = D.21606;
        vinfo->exception_type = 3;
        D.21599 = ctx->errors;
        D.21607 = monoeg_g_slist_prepend (D.21599, vinfo);
        ctx->errors = D.21607;
      }
      <D.21605>:
      ctx->valid = 0;
      return;
      <D.21603>:
      D.21608 = data[1];
      if (D.21608 == 0) goto <D.21609>; else goto <D.21610>;
      <D.21609>:
      D.21595 = ctx->report_error;
      if (D.21595 != 0) goto <D.21611>; else goto <D.21612>;
      <D.21611>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21613 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d NativeType field is null", i);
        vinfo->info.message = D.21613;
        vinfo->exception_type = 3;
        D.21599 = ctx->errors;
        D.21614 = monoeg_g_slist_prepend (D.21599, vinfo);
        ctx->errors = D.21614;
      }
      <D.21612>:
      ctx->valid = 0;
      return;
      <D.21610>:
      D.21608 = data[1];
      D.21615 = is_valid_blob_object (ctx, D.21608, 1);
      if (D.21615 == 0) goto <D.21616>; else goto <D.21617>;
      <D.21616>:
      D.21595 = ctx->report_error;
      if (D.21595 != 0) goto <D.21618>; else goto <D.21619>;
      <D.21618>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21608 = data[1];
        D.21620 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d invalid NativeType blob 0x%x", i, D.21608);
        vinfo->info.message = D.21620;
        vinfo->exception_type = 3;
        D.21599 = ctx->errors;
        D.21621 = monoeg_g_slist_prepend (D.21599, vinfo);
        ctx->errors = D.21621;
      }
      <D.21619>:
      ctx->valid = 0;
      return;
      <D.21617>:
      i = i + 1;
      <D.18637>:
      D.21622 = table->rows;
      D.21623 = (int) D.21622;
      if (D.21623 > i) goto <D.18636>; else goto <D.18638>;
      <D.18638>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_decl_security_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21627;
  unsigned int D.21628;
  int D.21629;
  int D.21632;
  gchar * D.21635;
  struct GSList * D.21636;
  struct GSList * D.21637;
  unsigned int D.21638;
  gchar * D.21643;
  struct GSList * D.21644;
  unsigned int D.21645;
  gchar * D.21650;
  struct GSList * D.21651;
  <unnamed-unsigned:24> D.21652;
  int D.21653;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.21627 = ctx->image;
      table = &D.21627->tables[14];
      i = 0;
      goto <D.18659>;
      <D.18658>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.21628 = data[1];
      D.21629 = is_valid_coded_index (ctx, 36, D.21628);
      if (D.21629 == 0) goto <D.21630>; else goto <D.21631>;
      <D.21630>:
      D.21632 = ctx->report_error;
      if (D.21632 != 0) goto <D.21633>; else goto <D.21634>;
      <D.21633>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21628 = data[1];
        D.21635 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d Parent field 0x%08x", i, D.21628);
        vinfo->info.message = D.21635;
        vinfo->exception_type = 3;
        D.21636 = ctx->errors;
        D.21637 = monoeg_g_slist_prepend (D.21636, vinfo);
        ctx->errors = D.21637;
      }
      <D.21634>:
      ctx->valid = 0;
      return;
      <D.21631>:
      D.21628 = data[1];
      D.21638 = get_coded_index_token (36, D.21628);
      if (D.21638 == 0) goto <D.21639>; else goto <D.21640>;
      <D.21639>:
      D.21632 = ctx->report_error;
      if (D.21632 != 0) goto <D.21641>; else goto <D.21642>;
      <D.21641>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21643 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d Parent field is null", i);
        vinfo->info.message = D.21643;
        vinfo->exception_type = 3;
        D.21636 = ctx->errors;
        D.21644 = monoeg_g_slist_prepend (D.21636, vinfo);
        ctx->errors = D.21644;
      }
      <D.21642>:
      ctx->valid = 0;
      return;
      <D.21640>:
      D.21645 = data[2];
      if (D.21645 == 0) goto <D.21646>; else goto <D.21647>;
      <D.21646>:
      D.21632 = ctx->report_error;
      if (D.21632 != 0) goto <D.21648>; else goto <D.21649>;
      <D.21648>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21650 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d PermissionSet field is null", i);
        vinfo->info.message = D.21650;
        vinfo->exception_type = 3;
        D.21636 = ctx->errors;
        D.21651 = monoeg_g_slist_prepend (D.21636, vinfo);
        ctx->errors = D.21651;
      }
      <D.21649>:
      ctx->valid = 0;
      return;
      <D.21647>:
      i = i + 1;
      <D.18659>:
      D.21652 = table->rows;
      D.21653 = (int) D.21652;
      if (D.21653 > i) goto <D.18658>; else goto <D.18660>;
      <D.18660>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_class_layout_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21657;
  unsigned int D.21660;
  <unnamed-unsigned:24> D.21662;
  int D.21663;
  int D.21664;
  unsigned int D.21665;
  int D.21666;
  gchar * D.21669;
  struct GSList * D.21670;
  struct GSList * D.21671;
  unsigned int D.21672;
  gchar * D.21675;
  struct GSList * D.21676;
  <unnamed-unsigned:24> D.21677;
  int D.21678;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.21657 = ctx->image;
      table = &D.21657->tables[15];
      i = 0;
      goto <D.18691>;
      <D.18690>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.21660 = data[2];
      if (D.21660 == 0) goto <D.21658>; else goto <D.21661>;
      <D.21661>:
      D.21660 = data[2];
      D.21657 = ctx->image;
      D.21662 = D.21657->tables[2].rows;
      D.21663 = (int) D.21662;
      D.21664 = D.21663 + 1;
      D.21665 = (unsigned int) D.21664;
      if (D.21660 > D.21665) goto <D.21658>; else goto <D.21659>;
      <D.21658>:
      D.21666 = ctx->report_error;
      if (D.21666 != 0) goto <D.21667>; else goto <D.21668>;
      <D.21667>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21660 = data[2];
        D.21669 = monoeg_g_strdup_printf ("Invalid ClassLayout row %d Parent field 0x%08x", i, D.21660);
        vinfo->info.message = D.21669;
        vinfo->exception_type = 3;
        D.21670 = ctx->errors;
        D.21671 = monoeg_g_slist_prepend (D.21670, vinfo);
        ctx->errors = D.21671;
      }
      <D.21668>:
      ctx->valid = 0;
      return;
      <D.21659>:
      D.21672 = data[0];
      switch (D.21672) <default: <D.18688>, case 0: <D.18678>, case 1: <D.18679>, case 2: <D.18680>, case 4: <D.18681>, case 8: <D.18682>, case 16: <D.18683>, case 32: <D.18684>, case 64: <D.18685>, case 128: <D.18686>>
      <D.18678>:
      <D.18679>:
      <D.18680>:
      <D.18681>:
      <D.18682>:
      <D.18683>:
      <D.18684>:
      <D.18685>:
      <D.18686>:
      goto <D.18687>;
      <D.18688>:
      D.21666 = ctx->report_error;
      if (D.21666 != 0) goto <D.21673>; else goto <D.21674>;
      <D.21673>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21672 = data[0];
        D.21675 = monoeg_g_strdup_printf ("Invalid ClassLayout row %d Packing field %d", i, D.21672);
        vinfo->info.message = D.21675;
        vinfo->exception_type = 3;
        D.21670 = ctx->errors;
        D.21676 = monoeg_g_slist_prepend (D.21670, vinfo);
        ctx->errors = D.21676;
      }
      <D.21674>:
      ctx->valid = 0;
      return;
      <D.18687>:
      i = i + 1;
      <D.18691>:
      D.21677 = table->rows;
      D.21678 = (int) D.21677;
      if (D.21678 > i) goto <D.18690>; else goto <D.18692>;
      <D.18692>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_field_layout_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21683;
  unsigned int D.21686;
  <unnamed-unsigned:24> D.21688;
  int D.21689;
  int D.21690;
  unsigned int D.21691;
  int D.21692;
  gchar * D.21695;
  struct GSList * D.21696;
  struct GSList * D.21697;
  <unnamed-unsigned:24> D.21698;
  int D.21699;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.21683 = ctx->image;
      table = &D.21683->tables[16];
      i = 0;
      goto <D.18701>;
      <D.18700>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.21686 = data[1];
      if (D.21686 == 0) goto <D.21684>; else goto <D.21687>;
      <D.21687>:
      D.21686 = data[1];
      D.21683 = ctx->image;
      D.21688 = D.21683->tables[4].rows;
      D.21689 = (int) D.21688;
      D.21690 = D.21689 + 1;
      D.21691 = (unsigned int) D.21690;
      if (D.21686 > D.21691) goto <D.21684>; else goto <D.21685>;
      <D.21684>:
      D.21692 = ctx->report_error;
      if (D.21692 != 0) goto <D.21693>; else goto <D.21694>;
      <D.21693>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21686 = data[1];
        D.21695 = monoeg_g_strdup_printf ("Invalid FieldLayout row %d Field field 0x%08x", i, D.21686);
        vinfo->info.message = D.21695;
        vinfo->exception_type = 3;
        D.21696 = ctx->errors;
        D.21697 = monoeg_g_slist_prepend (D.21696, vinfo);
        ctx->errors = D.21697;
      }
      <D.21694>:
      ctx->valid = 0;
      return;
      <D.21685>:
      i = i + 1;
      <D.18701>:
      D.21698 = table->rows;
      D.21699 = (int) D.21698;
      if (D.21699 > i) goto <D.18700>; else goto <D.18702>;
      <D.18702>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_standalonesig_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21703;
  unsigned int D.21704;
  int D.21707;
  int D.21710;
  gchar * D.21713;
  struct GSList * D.21714;
  struct GSList * D.21715;
  <unnamed-unsigned:24> D.21716;
  int D.21717;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.21703 = ctx->image;
      table = &D.21703->tables[17];
      i = 0;
      goto <D.18711>;
      <D.18710>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.21704 = data[0];
      if (D.21704 != 0) goto <D.21705>; else goto <D.21706>;
      <D.21705>:
      D.21704 = data[0];
      D.21707 = is_valid_blob_object (ctx, D.21704, 1);
      if (D.21707 == 0) goto <D.21708>; else goto <D.21709>;
      <D.21708>:
      D.21710 = ctx->report_error;
      if (D.21710 != 0) goto <D.21711>; else goto <D.21712>;
      <D.21711>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21704 = data[0];
        D.21713 = monoeg_g_strdup_printf ("Invalid StandAloneSig row %d invalid signature 0x%x", i, D.21704);
        vinfo->info.message = D.21713;
        vinfo->exception_type = 3;
        D.21714 = ctx->errors;
        D.21715 = monoeg_g_slist_prepend (D.21714, vinfo);
        ctx->errors = D.21715;
      }
      <D.21712>:
      ctx->valid = 0;
      return;
      <D.21709>:
      <D.21706>:
      i = i + 1;
      <D.18711>:
      D.21716 = table->rows;
      D.21717 = (int) D.21716;
      if (D.21717 > i) goto <D.18710>; else goto <D.18712>;
      <D.18712>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_eventmap_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21721;
  unsigned int D.21724;
  <unnamed-unsigned:24> D.21726;
  int D.21727;
  int D.21728;
  unsigned int D.21729;
  int D.21730;
  gchar * D.21733;
  struct GSList * D.21734;
  struct GSList * D.21735;
  unsigned int D.21738;
  gchar * D.21742;
  struct GSList * D.21743;
  <unnamed-unsigned:24> D.21744;
  int D.21745;
  struct MonoTableInfo * table;
  guint32 data[2];
  guint32 eventlist;
  int i;

  try
    {
      D.21721 = ctx->image;
      table = &D.21721->tables[18];
      eventlist = 0;
      i = 0;
      goto <D.18733>;
      <D.18732>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.21724 = data[0];
      if (D.21724 == 0) goto <D.21722>; else goto <D.21725>;
      <D.21725>:
      D.21724 = data[0];
      D.21721 = ctx->image;
      D.21726 = D.21721->tables[2].rows;
      D.21727 = (int) D.21726;
      D.21728 = D.21727 + 1;
      D.21729 = (unsigned int) D.21728;
      if (D.21724 > D.21729) goto <D.21722>; else goto <D.21723>;
      <D.21722>:
      D.21730 = ctx->report_error;
      if (D.21730 != 0) goto <D.21731>; else goto <D.21732>;
      <D.21731>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21724 = data[0];
        D.21733 = monoeg_g_strdup_printf ("Invalid EventMap row %d Parent field 0x%08x", i, D.21724);
        vinfo->info.message = D.21733;
        vinfo->exception_type = 3;
        D.21734 = ctx->errors;
        D.21735 = monoeg_g_slist_prepend (D.21734, vinfo);
        ctx->errors = D.21735;
      }
      <D.21732>:
      ctx->valid = 0;
      return;
      <D.21723>:
      D.21738 = data[1];
      if (D.21738 == 0) goto <D.21736>; else goto <D.21739>;
      <D.21739>:
      D.21738 = data[1];
      if (D.21738 <= eventlist) goto <D.21736>; else goto <D.21737>;
      <D.21736>:
      D.21730 = ctx->report_error;
      if (D.21730 != 0) goto <D.21740>; else goto <D.21741>;
      <D.21740>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21738 = data[1];
        D.21742 = monoeg_g_strdup_printf ("Invalid EventMap row %d EventList field %d", i, D.21738);
        vinfo->info.message = D.21742;
        vinfo->exception_type = 3;
        D.21734 = ctx->errors;
        D.21743 = monoeg_g_slist_prepend (D.21734, vinfo);
        ctx->errors = D.21743;
      }
      <D.21741>:
      ctx->valid = 0;
      return;
      <D.21737>:
      eventlist = data[1];
      i = i + 1;
      <D.18733>:
      D.21744 = table->rows;
      D.21745 = (int) D.21744;
      if (D.21745 > i) goto <D.18732>; else goto <D.18734>;
      <D.18734>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_event_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21749;
  unsigned int D.21750;
  unsigned int D.21751;
  int D.21754;
  gchar * D.21757;
  struct GSList * D.21758;
  struct GSList * D.21759;
  unsigned int D.21760;
  int D.21761;
  gchar * D.21766;
  struct GSList * D.21767;
  unsigned int D.21768;
  int D.21769;
  gchar * D.21774;
  struct GSList * D.21775;
  <unnamed-unsigned:24> D.21776;
  int D.21777;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.21749 = ctx->image;
      table = &D.21749->tables[20];
      i = 0;
      goto <D.18745>;
      <D.18744>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.21750 = data[0];
      D.21751 = D.21750 & 4294965759;
      if (D.21751 != 0) goto <D.21752>; else goto <D.21753>;
      <D.21752>:
      D.21754 = ctx->report_error;
      if (D.21754 != 0) goto <D.21755>; else goto <D.21756>;
      <D.21755>:
      {
        struct MonoVerifyInfoExtended * vinfo;

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

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21760 = data[1];
        D.21766 = monoeg_g_strdup_printf ("Invalid Event row %d Name field %08x", i, D.21760);
        vinfo->info.message = D.21766;
        vinfo->exception_type = 3;
        D.21758 = ctx->errors;
        D.21767 = monoeg_g_slist_prepend (D.21758, vinfo);
        ctx->errors = D.21767;
      }
      <D.21765>:
      ctx->valid = 0;
      return;
      <D.21763>:
      D.21768 = data[2];
      D.21769 = is_valid_coded_index (ctx, 0, D.21768);
      if (D.21769 == 0) goto <D.21770>; else goto <D.21771>;
      <D.21770>:
      D.21754 = ctx->report_error;
      if (D.21754 != 0) goto <D.21772>; else goto <D.21773>;
      <D.21772>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21768 = data[2];
        D.21774 = monoeg_g_strdup_printf ("Invalid Event row %d EventType field %08x", i, D.21768);
        vinfo->info.message = D.21774;
        vinfo->exception_type = 3;
        D.21758 = ctx->errors;
        D.21775 = monoeg_g_slist_prepend (D.21758, vinfo);
        ctx->errors = D.21775;
      }
      <D.21773>:
      ctx->valid = 0;
      return;
      <D.21771>:
      i = i + 1;
      <D.18745>:
      D.21776 = table->rows;
      D.21777 = (int) D.21776;
      if (D.21777 > i) goto <D.18744>; else goto <D.18746>;
      <D.18746>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_propertymap_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21781;
  unsigned int D.21784;
  <unnamed-unsigned:24> D.21786;
  int D.21787;
  int D.21788;
  unsigned int D.21789;
  int D.21790;
  gchar * D.21793;
  struct GSList * D.21794;
  struct GSList * D.21795;
  unsigned int D.21798;
  gchar * D.21802;
  struct GSList * D.21803;
  <unnamed-unsigned:24> D.21804;
  int D.21805;
  struct MonoTableInfo * table;
  guint32 data[2];
  guint32 propertylist;
  int i;

  try
    {
      D.21781 = ctx->image;
      table = &D.21781->tables[21];
      propertylist = 0;
      i = 0;
      goto <D.18781>;
      <D.18780>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.21784 = data[0];
      if (D.21784 == 0) goto <D.21782>; else goto <D.21785>;
      <D.21785>:
      D.21784 = data[0];
      D.21781 = ctx->image;
      D.21786 = D.21781->tables[2].rows;
      D.21787 = (int) D.21786;
      D.21788 = D.21787 + 1;
      D.21789 = (unsigned int) D.21788;
      if (D.21784 > D.21789) goto <D.21782>; else goto <D.21783>;
      <D.21782>:
      D.21790 = ctx->report_error;
      if (D.21790 != 0) goto <D.21791>; else goto <D.21792>;
      <D.21791>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21784 = data[0];
        D.21793 = monoeg_g_strdup_printf ("Invalid PropertyMap row %d Parent field 0x%08x", i, D.21784);
        vinfo->info.message = D.21793;
        vinfo->exception_type = 3;
        D.21794 = ctx->errors;
        D.21795 = monoeg_g_slist_prepend (D.21794, vinfo);
        ctx->errors = D.21795;
      }
      <D.21792>:
      ctx->valid = 0;
      return;
      <D.21783>:
      D.21798 = data[1];
      if (D.21798 == 0) goto <D.21796>; else goto <D.21799>;
      <D.21799>:
      D.21798 = data[1];
      if (D.21798 <= propertylist) goto <D.21796>; else goto <D.21797>;
      <D.21796>:
      D.21790 = ctx->report_error;
      if (D.21790 != 0) goto <D.21800>; else goto <D.21801>;
      <D.21800>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21798 = data[1];
        D.21802 = monoeg_g_strdup_printf ("Invalid PropertyMap row %d PropertyList field %d", i, D.21798);
        vinfo->info.message = D.21802;
        vinfo->exception_type = 3;
        D.21794 = ctx->errors;
        D.21803 = monoeg_g_slist_prepend (D.21794, vinfo);
        ctx->errors = D.21803;
      }
      <D.21801>:
      ctx->valid = 0;
      return;
      <D.21797>:
      propertylist = data[1];
      i = i + 1;
      <D.18781>:
      D.21804 = table->rows;
      D.21805 = (int) D.21804;
      if (D.21805 > i) goto <D.18780>; else goto <D.18782>;
      <D.18782>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_property_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21809;
  unsigned int D.21810;
  unsigned int D.21811;
  int D.21814;
  gchar * D.21817;
  struct GSList * D.21818;
  struct GSList * D.21819;
  unsigned int D.21820;
  int D.21821;
  gchar * D.21826;
  struct GSList * D.21827;
  unsigned int D.21828;
  int D.21829;
  gchar * D.21834;
  struct GSList * D.21835;
  unsigned int D.21836;
  unsigned int i.51;
  unsigned int D.21840;
  int D.21841;
  gchar * D.21846;
  struct GSList * D.21847;
  <unnamed-unsigned:24> D.21848;
  int D.21849;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.21809 = ctx->image;
      table = &D.21809->tables[23];
      i = 0;
      goto <D.18794>;
      <D.18793>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.21810 = data[0];
      D.21811 = D.21810 & 4294961663;
      if (D.21811 != 0) goto <D.21812>; else goto <D.21813>;
      <D.21812>:
      D.21814 = ctx->report_error;
      if (D.21814 != 0) goto <D.21815>; else goto <D.21816>;
      <D.21815>:
      {
        struct MonoVerifyInfoExtended * vinfo;

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

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21820 = data[1];
        D.21826 = monoeg_g_strdup_printf ("Invalid Property row %d Name field %08x", i, D.21820);
        vinfo->info.message = D.21826;
        vinfo->exception_type = 3;
        D.21818 = ctx->errors;
        D.21827 = monoeg_g_slist_prepend (D.21818, vinfo);
        ctx->errors = D.21827;
      }
      <D.21825>:
      ctx->valid = 0;
      return;
      <D.21823>:
      D.21828 = data[2];
      D.21829 = is_valid_property_sig_blob (ctx, D.21828);
      if (D.21829 == 0) goto <D.21830>; else goto <D.21831>;
      <D.21830>:
      D.21814 = ctx->report_error;
      if (D.21814 != 0) goto <D.21832>; else goto <D.21833>;
      <D.21832>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21828 = data[2];
        D.21834 = monoeg_g_strdup_printf ("Invalid Property row %d Type field %08x", i, D.21828);
        vinfo->info.message = D.21834;
        vinfo->exception_type = 3;
        D.21818 = ctx->errors;
        D.21835 = monoeg_g_slist_prepend (D.21818, vinfo);
        ctx->errors = D.21835;
      }
      <D.21833>:
      ctx->valid = 0;
      return;
      <D.21831>:
      D.21810 = data[0];
      D.21836 = D.21810 & 4096;
      if (D.21836 != 0) goto <D.21837>; else goto <D.21838>;
      <D.21837>:
      i.51 = (unsigned int) i;
      D.21840 = make_coded_token (5, 23, i.51);
      D.21841 = search_sorted_table (ctx, 11, 2, D.21840);
      if (D.21841 == -1) goto <D.21842>; else goto <D.21843>;
      <D.21842>:
      D.21814 = ctx->report_error;
      if (D.21814 != 0) goto <D.21844>; else goto <D.21845>;
      <D.21844>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21846 = 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.21846;
        vinfo->exception_type = 3;
        D.21818 = ctx->errors;
        D.21847 = monoeg_g_slist_prepend (D.21818, vinfo);
        ctx->errors = D.21847;
      }
      <D.21845>:
      ctx->valid = 0;
      return;
      <D.21843>:
      <D.21838>:
      i = i + 1;
      <D.18794>:
      D.21848 = table->rows;
      D.21849 = (int) D.21848;
      if (D.21849 > i) goto <D.18793>; else goto <D.18795>;
      <D.18795>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_property_sig_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.21853;
  int D.21856;
  gchar * D.21859;
  struct GSList * D.21860;
  struct GSList * D.21861;
  gboolean D.21862;
  const char * ptr.52;
  unsigned int size.53;
  guint32 size;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      ptr = 0B;
      D.21853 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.21853 == 0) goto <D.21854>; else goto <D.21855>;
      <D.21854>:
      D.21856 = ctx->report_error;
      if (D.21856 != 0) goto <D.21857>; else goto <D.21858>;
      <D.21857>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21859 = monoeg_strdup ("PropertySig: Could not decode signature header");
        vinfo->info.message = D.21859;
        vinfo->exception_type = 3;
        D.21860 = ctx->errors;
        D.21861 = monoeg_g_slist_prepend (D.21860, vinfo);
        ctx->errors = D.21861;
      }
      <D.21858>:
      ctx->valid = 0;
      D.21862 = 0;
      return D.21862;
      <D.21855>:
      ptr.52 = ptr;
      size.53 = size;
      end = ptr.52 + size.53;
      D.21862 = parse_property_signature (ctx, &ptr, end);
      return D.21862;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


decode_signature_header (struct VerifyContext * ctx, guint32 offset, guint32 * size, const char * * first_byte)
{
  struct MonoImage * D.21867;
  unsigned int D.21868;
  gboolean D.21871;
  const char * D.21872;
  const char * D.21873;
  unsigned int D.21874;
  int D.21875;
  unsigned int enc_size.54;
  unsigned int D.21879;
  unsigned int value.55;
  unsigned int D.21885;
  unsigned int D.21887;
  struct MonoStreamHeader blob;
  guint32 value;
  guint32 enc_size;

  try
    {
      D.21867 = ctx->image;
      blob = D.21867->heap_blob;
      D.21868 = blob.size;
      if (D.21868 <= offset) goto <D.21869>; else goto <D.21870>;
      <D.21869>:
      D.21871 = 0;
      return D.21871;
      <D.21870>:
      D.21872 = blob.data;
      D.21873 = D.21872 + offset;
      D.21868 = blob.size;
      D.21874 = D.21868 - offset;
      D.21875 = decode_value (D.21873, D.21874, &value, &enc_size);
      if (D.21875 == 0) goto <D.21876>; else goto <D.21877>;
      <D.21876>:
      D.21871 = 0;
      return D.21871;
      <D.21877>:
      enc_size.54 = enc_size;
      D.21879 = ~enc_size.54;
      if (D.21879 < offset) goto <D.21880>; else goto <D.21881>;
      <D.21880>:
      D.21871 = 0;
      return D.21871;
      <D.21881>:
      enc_size.54 = enc_size;
      offset = offset + enc_size.54;
      value.55 = value;
      D.21885 = offset + value.55;
      D.21868 = blob.size;
      if (D.21885 > D.21868) goto <D.21882>; else goto <D.21886>;
      <D.21886>:
      value.55 = value;
      D.21887 = ~value.55;
      if (D.21887 < offset) goto <D.21882>; else goto <D.21883>;
      <D.21882>:
      D.21871 = 0;
      return D.21871;
      <D.21883>:
      value.55 = value;
      *size = value.55;
      D.21872 = blob.data;
      D.21873 = D.21872 + offset;
      *first_byte = D.21873;
      D.21871 = 1;
      return D.21871;
    }
  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.21891;
  int D.21894;
  gchar * D.21897;
  struct GSList * D.21898;
  struct GSList * D.21899;
  gboolean D.21900;
  unsigned int sig.57;
  gchar * D.21908;
  struct GSList * D.21909;
  int D.21910;
  gchar * D.21915;
  struct GSList * D.21916;
  int D.21917;
  int D.21920;
  gchar * D.21925;
  struct GSList * D.21926;
  int D.21927;
  gchar * D.21932;
  struct GSList * D.21933;
  int D.21934;
  gchar * D.21939;
  struct GSList * D.21940;
  unsigned int param_count.58;
  const char * ptr.59;
  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.21891 = safe_read (&ptr, end, &sig, 1);
      if (D.21891 == 0) goto <D.21892>; else goto <D.21893>;
      <D.21892>:
      D.21894 = ctx->report_error;
      if (D.21894 != 0) goto <D.21895>; else goto <D.21896>;
      <D.21895>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21897 = monoeg_strdup ("PropertySig: Not enough room for signature");
        vinfo->info.message = D.21897;
        vinfo->exception_type = 3;
        D.21898 = ctx->errors;
        D.21899 = monoeg_g_slist_prepend (D.21898, vinfo);
        ctx->errors = D.21899;
      }
      <D.21896>:
      ctx->valid = 0;
      D.21900 = 0;
      return D.21900;
      <D.21893>:
      sig.57 = sig;
      if (sig.57 != 8) goto <D.21902>; else goto <D.21903>;
      <D.21902>:
      sig.57 = sig;
      if (sig.57 != 40) goto <D.21904>; else goto <D.21905>;
      <D.21904>:
      D.21894 = ctx->report_error;
      if (D.21894 != 0) goto <D.21906>; else goto <D.21907>;
      <D.21906>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        sig.57 = sig;
        D.21908 = monoeg_g_strdup_printf ("PropertySig: Signature is not 0x28 or 0x08: %x", sig.57);
        vinfo->info.message = D.21908;
        vinfo->exception_type = 3;
        D.21898 = ctx->errors;
        D.21909 = monoeg_g_slist_prepend (D.21898, vinfo);
        ctx->errors = D.21909;
      }
      <D.21907>:
      ctx->valid = 0;
      D.21900 = 0;
      return D.21900;
      <D.21905>:
      <D.21903>:
      D.21910 = safe_read_compressed_int (&ptr, end, &param_count);
      if (D.21910 == 0) goto <D.21911>; else goto <D.21912>;
      <D.21911>:
      D.21894 = ctx->report_error;
      if (D.21894 != 0) goto <D.21913>; else goto <D.21914>;
      <D.21913>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21915 = monoeg_strdup ("PropertySig: Not enough room for the param count");
        vinfo->info.message = D.21915;
        vinfo->exception_type = 3;
        D.21898 = ctx->errors;
        D.21916 = monoeg_g_slist_prepend (D.21898, vinfo);
        ctx->errors = D.21916;
      }
      <D.21914>:
      ctx->valid = 0;
      D.21900 = 0;
      return D.21900;
      <D.21912>:
      D.21917 = parse_custom_mods (ctx, &ptr, end);
      if (D.21917 == 0) goto <D.21918>; else goto <D.21919>;
      <D.21918>:
      D.21900 = 0;
      return D.21900;
      <D.21919>:
      D.21920 = parse_type (ctx, &ptr, end);
      if (D.21920 == 0) goto <D.21921>; else goto <D.21922>;
      <D.21921>:
      D.21894 = ctx->report_error;
      if (D.21894 != 0) goto <D.21923>; else goto <D.21924>;
      <D.21923>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21925 = monoeg_strdup ("PropertySig: Could not parse property type");
        vinfo->info.message = D.21925;
        vinfo->exception_type = 3;
        D.21898 = ctx->errors;
        D.21926 = monoeg_g_slist_prepend (D.21898, vinfo);
        ctx->errors = D.21926;
      }
      <D.21924>:
      ctx->valid = 0;
      D.21900 = 0;
      return D.21900;
      <D.21922>:
      i = 0;
      goto <D.17977>;
      <D.17976>:
      D.21927 = parse_custom_mods (ctx, &ptr, end);
      if (D.21927 == 0) goto <D.21928>; else goto <D.21929>;
      <D.21928>:
      D.21894 = ctx->report_error;
      if (D.21894 != 0) goto <D.21930>; else goto <D.21931>;
      <D.21930>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21932 = monoeg_strdup ("Type: Failed to parse pointer custom attr");
        vinfo->info.message = D.21932;
        vinfo->exception_type = 3;
        D.21898 = ctx->errors;
        D.21933 = monoeg_g_slist_prepend (D.21898, vinfo);
        ctx->errors = D.21933;
      }
      <D.21931>:
      ctx->valid = 0;
      D.21900 = 0;
      return D.21900;
      <D.21929>:
      D.21934 = parse_type (ctx, &ptr, end);
      if (D.21934 == 0) goto <D.21935>; else goto <D.21936>;
      <D.21935>:
      D.21894 = ctx->report_error;
      if (D.21894 != 0) goto <D.21937>; else goto <D.21938>;
      <D.21937>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21939 = monoeg_g_strdup_printf ("PropertySig: Error parsing arg %d", i);
        vinfo->info.message = D.21939;
        vinfo->exception_type = 3;
        D.21898 = ctx->errors;
        D.21940 = monoeg_g_slist_prepend (D.21898, vinfo);
        ctx->errors = D.21940;
      }
      <D.21938>:
      ctx->valid = 0;
      D.21900 = 0;
      return D.21900;
      <D.21936>:
      i = i + 1;
      <D.17977>:
      param_count.58 = param_count;
      if (i < param_count.58) goto <D.17976>; else goto <D.17978>;
      <D.17978>:
      ptr.59 = ptr;
      *_ptr = ptr.59;
      D.21900 = 1;
      return D.21900;
    }
  finally
    {
      sig = {CLOBBER};
      param_count = {CLOBBER};
      ptr = {CLOBBER};
    }
}


safe_read (const char * * _ptr, const char * limit, unsigned int * dest, int size)
{
  sizetype size.60;
  const char * D.21946;
  gboolean D.21949;
  unsigned char D.21950;
  unsigned int D.21951;
  short unsigned int D.21952;
  unsigned int D.21953;
  unsigned int D.21954;
  const char * ptr;

  ptr = *_ptr;
  size.60 = (sizetype) size;
  D.21946 = ptr + size.60;
  if (D.21946 > limit) goto <D.21947>; else goto <D.21948>;
  <D.21947>:
  D.21949 = 0;
  return D.21949;
  <D.21948>:
  switch (size) <default: <D.21955>, case 1: <D.17802>, case 2: <D.17804>, case 4: <D.17805>>
  <D.17802>:
  D.21950 = MEM[(guint8 *)ptr];
  D.21951 = (unsigned int) D.21950;
  *dest = D.21951;
  ptr = ptr + 1;
  goto <D.17803>;
  <D.17804>:
  D.21952 = mono_read16 (ptr);
  D.21953 = (unsigned int) D.21952;
  *dest = D.21953;
  ptr = ptr + 2;
  goto <D.17803>;
  <D.17805>:
  D.21954 = mono_read32 (ptr);
  *dest = D.21954;
  ptr = ptr + 4;
  goto <D.17803>;
  <D.21955>:
  <D.17803>:
  *_ptr = ptr;
  D.21949 = 1;
  return D.21949;
}


safe_read_compressed_int (const char * * _ptr, const char * limit, unsigned int * dest)
{
  int limit.61;
  int ptr.62;
  int D.21959;
  unsigned int D.21960;
  unsigned int size.63;
  const char * D.21962;
  gboolean D.21963;
  unsigned int size;
  const char * ptr;
  gboolean res;

  try
    {
      size = 0;
      ptr = *_ptr;
      limit.61 = (int) limit;
      ptr.62 = (int) ptr;
      D.21959 = limit.61 - ptr.62;
      D.21960 = (unsigned int) D.21959;
      res = decode_value (ptr, D.21960, dest, &size);
      size.63 = size;
      D.21962 = ptr + size.63;
      *_ptr = D.21962;
      D.21963 = res;
      return D.21963;
    }
  finally
    {
      size = {CLOBBER};
    }
}


parse_custom_mods (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.64;
  int D.21967;
  int D.21970;
  gchar * D.21973;
  struct GSList * D.21974;
  struct GSList * D.21975;
  gboolean D.21976;
  unsigned int type.65;
  unsigned int D.21978;
  const char * ptr.66;
  const char * ptr.67;
  int D.21983;
  gchar * D.21988;
  struct GSList * D.21989;
  unsigned int token.68;
  int D.21993;
  unsigned int D.21995;
  gchar * D.21998;
  struct GSList * D.21999;
  const char * ptr;
  unsigned int type;
  unsigned int token;

  try
    {
      ptr.64 = *_ptr;
      ptr = ptr.64;
      type = 0;
      token = 0;
      <D.17836>:
      D.21967 = safe_read (&ptr, end, &type, 1);
      if (D.21967 == 0) goto <D.21968>; else goto <D.21969>;
      <D.21968>:
      D.21970 = ctx->report_error;
      if (D.21970 != 0) goto <D.21971>; else goto <D.21972>;
      <D.21971>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21973 = monoeg_strdup ("CustomMod: Not enough room for the type");
        vinfo->info.message = D.21973;
        vinfo->exception_type = 3;
        D.21974 = ctx->errors;
        D.21975 = monoeg_g_slist_prepend (D.21974, vinfo);
        ctx->errors = D.21975;
      }
      <D.21972>:
      ctx->valid = 0;
      D.21976 = 0;
      return D.21976;
      <D.21969>:
      type.65 = type;
      D.21978 = type.65 + 4294967265;
      if (D.21978 > 1) goto <D.21979>; else goto <D.21980>;
      <D.21979>:
      ptr.66 = ptr;
      ptr.67 = ptr.66 + 4294967295;
      ptr = ptr.67;
      goto <D.17833>;
      <D.21980>:
      D.21983 = safe_read_compressed_int (&ptr, end, &token);
      if (D.21983 == 0) goto <D.21984>; else goto <D.21985>;
      <D.21984>:
      D.21970 = ctx->report_error;
      if (D.21970 != 0) goto <D.21986>; else goto <D.21987>;
      <D.21986>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.21988 = monoeg_strdup ("CustomMod: Not enough room for the token");
        vinfo->info.message = D.21988;
        vinfo->exception_type = 3;
        D.21974 = ctx->errors;
        D.21989 = monoeg_g_slist_prepend (D.21974, vinfo);
        ctx->errors = D.21989;
      }
      <D.21987>:
      ctx->valid = 0;
      D.21976 = 0;
      return D.21976;
      <D.21985>:
      token.68 = token;
      D.21993 = is_valid_coded_index (ctx, 0, token.68);
      if (D.21993 == 0) goto <D.21990>; else goto <D.21994>;
      <D.21994>:
      token.68 = token;
      D.21995 = get_coded_index_token (0, token.68);
      if (D.21995 == 0) goto <D.21990>; else goto <D.21991>;
      <D.21990>:
      D.21970 = ctx->report_error;
      if (D.21970 != 0) goto <D.21996>; else goto <D.21997>;
      <D.21996>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        token.68 = token;
        D.21998 = monoeg_g_strdup_printf ("CustomMod: invalid TypeDefOrRef token %x", token.68);
        vinfo->info.message = D.21998;
        vinfo->exception_type = 3;
        D.21974 = ctx->errors;
        D.21999 = monoeg_g_slist_prepend (D.21974, vinfo);
        ctx->errors = D.21999;
      }
      <D.21997>:
      ctx->valid = 0;
      D.21976 = 0;
      return D.21976;
      <D.21991>:
      goto <D.17836>;
      <D.17833>:
      ptr.66 = ptr;
      *_ptr = ptr.66;
      D.21976 = 1;
      return D.21976;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
      token = {CLOBBER};
    }
}


parse_type (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.69;
  int D.22003;
  int D.22006;
  gchar * D.22009;
  struct GSList * D.22010;
  struct GSList * D.22011;
  gboolean D.22012;
  unsigned int type.70;
  unsigned int D.22014;
  unsigned int D.22017;
  unsigned int D.22020;
  unsigned int D.22023;
  gchar * D.22028;
  struct GSList * D.22029;
  int D.22030;
  gchar * D.22035;
  struct GSList * D.22036;
  int D.22037;
  gchar * D.22042;
  struct GSList * D.22043;
  const char * ptr.71;
  const char * ptr.72;
  int D.22048;
  gchar * D.22053;
  struct GSList * D.22054;
  int D.22055;
  gchar * D.22060;
  struct GSList * D.22061;
  unsigned int token.73;
  int D.22065;
  unsigned int D.22067;
  gchar * D.22070;
  struct GSList * D.22071;
  unsigned int D.22072;
  gchar * D.22077;
  struct GSList * D.22078;
  unsigned int D.22079;
  unsigned int D.22082;
  unsigned int D.22083;
  unsigned int D.22086;
  unsigned int D.22087;
  gchar * D.22092;
  struct GSList * D.22093;
  int D.22094;
  gchar * D.22099;
  struct GSList * D.22100;
  int D.22101;
  gchar * D.22106;
  struct GSList * D.22107;
  int D.22108;
  gchar * D.22113;
  struct GSList * D.22114;
  int D.22115;
  gchar * D.22120;
  struct GSList * D.22121;
  int D.22122;
  gchar * D.22127;
  struct GSList * D.22128;
  int D.22129;
  gchar * D.22134;
  struct GSList * D.22135;
  int D.22136;
  gchar * D.22141;
  struct GSList * D.22142;
  const char * ptr;
  unsigned int type;
  unsigned int token;

  try
    {
      ptr.69 = *_ptr;
      ptr = ptr.69;
      token = 0;
      D.22003 = safe_read (&ptr, end, &type, 1);
      if (D.22003 == 0) goto <D.22004>; else goto <D.22005>;
      <D.22004>:
      D.22006 = ctx->report_error;
      if (D.22006 != 0) goto <D.22007>; else goto <D.22008>;
      <D.22007>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22009 = monoeg_strdup ("Type: Not enough room for the type");
        vinfo->info.message = D.22009;
        vinfo->exception_type = 3;
        D.22010 = ctx->errors;
        D.22011 = monoeg_g_slist_prepend (D.22010, vinfo);
        ctx->errors = D.22011;
      }
      <D.22008>:
      ctx->valid = 0;
      D.22012 = 0;
      return D.22012;
      <D.22005>:
      type.70 = type;
      D.22014 = type.70 + 4294967294;
      if (D.22014 > 13) goto <D.22015>; else goto <D.22016>;
      <D.22015>:
      type.70 = type;
      D.22017 = type.70 + 4294967279;
      if (D.22017 > 4) goto <D.22018>; else goto <D.22019>;
      <D.22018>:
      type.70 = type;
      D.22020 = type.70 + 4294967272;
      if (D.22020 > 1) goto <D.22021>; else goto <D.22022>;
      <D.22021>:
      type.70 = type;
      D.22023 = type.70 + 4294967269;
      if (D.22023 > 3) goto <D.22024>; else goto <D.22025>;
      <D.22024>:
      D.22006 = ctx->report_error;
      if (D.22006 != 0) goto <D.22026>; else goto <D.22027>;
      <D.22026>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        type.70 = type;
        D.22028 = monoeg_g_strdup_printf ("Type: Invalid type kind %x\n", type.70);
        vinfo->info.message = D.22028;
        vinfo->exception_type = 3;
        D.22010 = ctx->errors;
        D.22029 = monoeg_g_slist_prepend (D.22010, vinfo);
        ctx->errors = D.22029;
      }
      <D.22027>:
      ctx->valid = 0;
      D.22012 = 0;
      return D.22012;
      <D.22025>:
      <D.22022>:
      <D.22019>:
      <D.22016>:
      type.70 = type;
      switch (type.70) <default: <D.22143>, case 15: <D.17891>, case 17: <D.17896>, case 18: <D.17897>, case 19: <D.17902>, case 20: <D.17905>, case 21: <D.17908>, case 27: <D.17910>, case 29: <D.17912>, case 30: <D.17903>>
      <D.17891>:
      D.22030 = parse_custom_mods (ctx, &ptr, end);
      if (D.22030 == 0) goto <D.22031>; else goto <D.22032>;
      <D.22031>:
      D.22006 = ctx->report_error;
      if (D.22006 != 0) goto <D.22033>; else goto <D.22034>;
      <D.22033>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22035 = monoeg_strdup ("Type: Failed to parse pointer custom attr");
        vinfo->info.message = D.22035;
        vinfo->exception_type = 3;
        D.22010 = ctx->errors;
        D.22036 = monoeg_g_slist_prepend (D.22010, vinfo);
        ctx->errors = D.22036;
      }
      <D.22034>:
      ctx->valid = 0;
      D.22012 = 0;
      return D.22012;
      <D.22032>:
      D.22037 = safe_read (&ptr, end, &type, 1);
      if (D.22037 == 0) goto <D.22038>; else goto <D.22039>;
      <D.22038>:
      D.22006 = ctx->report_error;
      if (D.22006 != 0) goto <D.22040>; else goto <D.22041>;
      <D.22040>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22042 = monoeg_strdup ("Type: Not enough room to parse the pointer type");
        vinfo->info.message = D.22042;
        vinfo->exception_type = 3;
        D.22010 = ctx->errors;
        D.22043 = monoeg_g_slist_prepend (D.22010, vinfo);
        ctx->errors = D.22043;
      }
      <D.22041>:
      ctx->valid = 0;
      D.22012 = 0;
      return D.22012;
      <D.22039>:
      type.70 = type;
      if (type.70 != 1) goto <D.22044>; else goto <D.22045>;
      <D.22044>:
      ptr.71 = ptr;
      ptr.72 = ptr.71 + 4294967295;
      ptr = ptr.72;
      D.22048 = parse_type (ctx, &ptr, end);
      if (D.22048 == 0) goto <D.22049>; else goto <D.22050>;
      <D.22049>:
      D.22006 = ctx->report_error;
      if (D.22006 != 0) goto <D.22051>; else goto <D.22052>;
      <D.22051>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22053 = monoeg_strdup ("Type: Could not parse pointer type");
        vinfo->info.message = D.22053;
        vinfo->exception_type = 3;
        D.22010 = ctx->errors;
        D.22054 = monoeg_g_slist_prepend (D.22010, vinfo);
        ctx->errors = D.22054;
      }
      <D.22052>:
      ctx->valid = 0;
      D.22012 = 0;
      return D.22012;
      <D.22050>:
      <D.22045>:
      goto <D.17895>;
      <D.17896>:
      <D.17897>:
      D.22055 = safe_read_compressed_int (&ptr, end, &token);
      if (D.22055 == 0) goto <D.22056>; else goto <D.22057>;
      <D.22056>:
      D.22006 = ctx->report_error;
      if (D.22006 != 0) goto <D.22058>; else goto <D.22059>;
      <D.22058>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22060 = monoeg_strdup ("Type: Not enough room for the type token");
        vinfo->info.message = D.22060;
        vinfo->exception_type = 3;
        D.22010 = ctx->errors;
        D.22061 = monoeg_g_slist_prepend (D.22010, vinfo);
        ctx->errors = D.22061;
      }
      <D.22059>:
      ctx->valid = 0;
      D.22012 = 0;
      return D.22012;
      <D.22057>:
      token.73 = token;
      D.22065 = is_valid_coded_index (ctx, 0, token.73);
      if (D.22065 == 0) goto <D.22062>; else goto <D.22066>;
      <D.22066>:
      token.73 = token;
      D.22067 = get_coded_index_token (0, token.73);
      if (D.22067 == 0) goto <D.22062>; else goto <D.22063>;
      <D.22062>:
      D.22006 = ctx->report_error;
      if (D.22006 != 0) goto <D.22068>; else goto <D.22069>;
      <D.22068>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        token.73 = token;
        D.22070 = monoeg_g_strdup_printf ("Type: invalid TypeDefOrRef token %x", token.73);
        vinfo->info.message = D.22070;
        vinfo->exception_type = 3;
        D.22010 = ctx->errors;
        D.22071 = monoeg_g_slist_prepend (D.22010, vinfo);
        ctx->errors = D.22071;
      }
      <D.22069>:
      ctx->valid = 0;
      D.22012 = 0;
      return D.22012;
      <D.22063>:
      token.73 = token;
      D.22072 = get_coded_index_token (0, token.73);
      if (D.22072 == 0) goto <D.22073>; else goto <D.22074>;
      <D.22073>:
      D.22006 = ctx->report_error;
      if (D.22006 != 0) goto <D.22075>; else goto <D.22076>;
      <D.22075>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        token.73 = token;
        D.22077 = monoeg_g_strdup_printf ("Type: zero TypeDefOrRef token %x", token.73);
        vinfo->info.message = D.22077;
        vinfo->exception_type = 3;
        D.22010 = ctx->errors;
        D.22078 = monoeg_g_slist_prepend (D.22010, vinfo);
        ctx->errors = D.22078;
      }
      <D.22076>:
      ctx->valid = 0;
      D.22012 = 0;
      return D.22012;
      <D.22074>:
      D.22079 = ctx->token;
      if (D.22079 != 0) goto <D.22080>; else goto <D.22081>;
      <D.22080>:
      D.22079 = ctx->token;
      D.22082 = D.22079 & 16777215;
      token.73 = token;
      D.22083 = get_coded_index_token (0, token.73);
      if (D.22082 == D.22083) goto <D.22084>; else goto <D.22085>;
      <D.22084>:
      D.22079 = ctx->token;
      D.22086 = D.22079 >> 24;
      token.73 = token;
      D.22087 = get_coded_index_table (0, token.73);
      if (D.22086 == D.22087) goto <D.22088>; else goto <D.22089>;
      <D.22088>:
      D.22006 = ctx->report_error;
      if (D.22006 != 0) goto <D.22090>; else goto <D.22091>;
      <D.22090>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22079 = ctx->token;
        D.22092 = monoeg_g_strdup_printf ("Type: Recursive type specification (%x). A type signature can\'t reference itself", D.22079);
        vinfo->info.message = D.22092;
        vinfo->exception_type = 3;
        D.22010 = ctx->errors;
        D.22093 = monoeg_g_slist_prepend (D.22010, vinfo);
        ctx->errors = D.22093;
      }
      <D.22091>:
      ctx->valid = 0;
      D.22012 = 0;
      return D.22012;
      <D.22089>:
      <D.22085>:
      <D.22081>:
      goto <D.17895>;
      <D.17902>:
      <D.17903>:
      D.22094 = safe_read_compressed_int (&ptr, end, &token);
      if (D.22094 == 0) goto <D.22095>; else goto <D.22096>;
      <D.22095>:
      D.22006 = ctx->report_error;
      if (D.22006 != 0) goto <D.22097>; else goto <D.22098>;
      <D.22097>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22099 = monoeg_strdup ("Type: Not enough room for to decode generic argument number");
        vinfo->info.message = D.22099;
        vinfo->exception_type = 3;
        D.22010 = ctx->errors;
        D.22100 = monoeg_g_slist_prepend (D.22010, vinfo);
        ctx->errors = D.22100;
      }
      <D.22098>:
      ctx->valid = 0;
      D.22012 = 0;
      return D.22012;
      <D.22096>:
      goto <D.17895>;
      <D.17905>:
      D.22101 = parse_type (ctx, &ptr, end);
      if (D.22101 == 0) goto <D.22102>; else goto <D.22103>;
      <D.22102>:
      D.22006 = ctx->report_error;
      if (D.22006 != 0) goto <D.22104>; else goto <D.22105>;
      <D.22104>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22106 = monoeg_strdup ("Type: Could not parse array type");
        vinfo->info.message = D.22106;
        vinfo->exception_type = 3;
        D.22010 = ctx->errors;
        D.22107 = monoeg_g_slist_prepend (D.22010, vinfo);
        ctx->errors = D.22107;
      }
      <D.22105>:
      ctx->valid = 0;
      D.22012 = 0;
      return D.22012;
      <D.22103>:
      D.22108 = parse_array_shape (ctx, &ptr, end);
      if (D.22108 == 0) goto <D.22109>; else goto <D.22110>;
      <D.22109>:
      D.22006 = ctx->report_error;
      if (D.22006 != 0) goto <D.22111>; else goto <D.22112>;
      <D.22111>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22113 = monoeg_strdup ("Type: Could not parse array shape");
        vinfo->info.message = D.22113;
        vinfo->exception_type = 3;
        D.22010 = ctx->errors;
        D.22114 = monoeg_g_slist_prepend (D.22010, vinfo);
        ctx->errors = D.22114;
      }
      <D.22112>:
      ctx->valid = 0;
      D.22012 = 0;
      return D.22012;
      <D.22110>:
      goto <D.17895>;
      <D.17908>:
      D.22115 = parse_generic_inst (ctx, &ptr, end);
      if (D.22115 == 0) goto <D.22116>; else goto <D.22117>;
      <D.22116>:
      D.22006 = ctx->report_error;
      if (D.22006 != 0) goto <D.22118>; else goto <D.22119>;
      <D.22118>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22120 = monoeg_strdup ("Type: Could not parse generic inst");
        vinfo->info.message = D.22120;
        vinfo->exception_type = 3;
        D.22010 = ctx->errors;
        D.22121 = monoeg_g_slist_prepend (D.22010, vinfo);
        ctx->errors = D.22121;
      }
      <D.22119>:
      ctx->valid = 0;
      D.22012 = 0;
      return D.22012;
      <D.22117>:
      goto <D.17895>;
      <D.17910>:
      D.22122 = parse_method_signature (ctx, &ptr, end, 1, 1);
      if (D.22122 == 0) goto <D.22123>; else goto <D.22124>;
      <D.22123>:
      D.22006 = ctx->report_error;
      if (D.22006 != 0) goto <D.22125>; else goto <D.22126>;
      <D.22125>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22127 = monoeg_strdup ("Type: Could not parse method pointer signature");
        vinfo->info.message = D.22127;
        vinfo->exception_type = 3;
        D.22010 = ctx->errors;
        D.22128 = monoeg_g_slist_prepend (D.22010, vinfo);
        ctx->errors = D.22128;
      }
      <D.22126>:
      ctx->valid = 0;
      D.22012 = 0;
      return D.22012;
      <D.22124>:
      goto <D.17895>;
      <D.17912>:
      D.22129 = parse_custom_mods (ctx, &ptr, end);
      if (D.22129 == 0) goto <D.22130>; else goto <D.22131>;
      <D.22130>:
      D.22006 = ctx->report_error;
      if (D.22006 != 0) goto <D.22132>; else goto <D.22133>;
      <D.22132>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22134 = monoeg_strdup ("Type: Failed to parse array element custom attr");
        vinfo->info.message = D.22134;
        vinfo->exception_type = 3;
        D.22010 = ctx->errors;
        D.22135 = monoeg_g_slist_prepend (D.22010, vinfo);
        ctx->errors = D.22135;
      }
      <D.22133>:
      ctx->valid = 0;
      D.22012 = 0;
      return D.22012;
      <D.22131>:
      D.22136 = parse_type (ctx, &ptr, end);
      if (D.22136 == 0) goto <D.22137>; else goto <D.22138>;
      <D.22137>:
      D.22006 = ctx->report_error;
      if (D.22006 != 0) goto <D.22139>; else goto <D.22140>;
      <D.22139>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22141 = monoeg_strdup ("Type: Could not parse array type");
        vinfo->info.message = D.22141;
        vinfo->exception_type = 3;
        D.22010 = ctx->errors;
        D.22142 = monoeg_g_slist_prepend (D.22010, vinfo);
        ctx->errors = D.22142;
      }
      <D.22140>:
      ctx->valid = 0;
      D.22012 = 0;
      return D.22012;
      <D.22138>:
      goto <D.17895>;
      <D.22143>:
      <D.17895>:
      ptr.71 = ptr;
      *_ptr = ptr.71;
      D.22012 = 1;
      return D.22012;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
      token = {CLOBBER};
    }
}


get_coded_index_table (int kind, guint32 coded_token)
{
  unsigned char D.22146;
  int bits.74;
  int D.22148;
  int D.22149;
  unsigned int D.22150;
  guint32 D.22151;
  unsigned int kind.75;
  unsigned int D.22153;
  unsigned char D.22154;
  guint32 idx;
  guint32 bits;

  D.22146 = coded_index_desc[kind];
  bits = (guint32) D.22146;
  kind = kind + 2;
  bits.74 = (int) bits;
  D.22148 = 1 << bits.74;
  D.22149 = D.22148 + -1;
  D.22150 = (unsigned int) D.22149;
  idx = D.22150 & coded_token;
  kind.75 = (unsigned int) kind;
  D.22153 = kind.75 + idx;
  D.22154 = coded_index_desc[D.22153];
  D.22151 = (guint32) D.22154;
  return D.22151;
}


parse_array_shape (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.76;
  int D.22157;
  int D.22160;
  gchar * D.22163;
  struct GSList * D.22164;
  struct GSList * D.22165;
  gboolean D.22166;
  unsigned int val.77;
  gchar * D.22172;
  struct GSList * D.22173;
  int D.22174;
  gchar * D.22179;
  struct GSList * D.22180;
  int D.22181;
  unsigned int D.22186;
  gchar * D.22187;
  struct GSList * D.22188;
  unsigned int size.78;
  int D.22190;
  gchar * D.22195;
  struct GSList * D.22196;
  int D.22197;
  gchar * D.22202;
  struct GSList * D.22203;
  const char * ptr.79;
  const char * ptr;
  unsigned int val;
  unsigned int size;
  unsigned int num;
  unsigned int i;

  try
    {
      ptr.76 = *_ptr;
      ptr = ptr.76;
      val = 0;
      D.22157 = safe_read (&ptr, end, &val, 1);
      if (D.22157 == 0) goto <D.22158>; else goto <D.22159>;
      <D.22158>:
      D.22160 = ctx->report_error;
      if (D.22160 != 0) goto <D.22161>; else goto <D.22162>;
      <D.22161>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22163 = monoeg_strdup ("ArrayShape: Not enough room for Rank");
        vinfo->info.message = D.22163;
        vinfo->exception_type = 3;
        D.22164 = ctx->errors;
        D.22165 = monoeg_g_slist_prepend (D.22164, vinfo);
        ctx->errors = D.22165;
      }
      <D.22162>:
      ctx->valid = 0;
      D.22166 = 0;
      return D.22166;
      <D.22159>:
      val.77 = val;
      if (val.77 == 0) goto <D.22168>; else goto <D.22169>;
      <D.22168>:
      D.22160 = ctx->report_error;
      if (D.22160 != 0) goto <D.22170>; else goto <D.22171>;
      <D.22170>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22172 = monoeg_strdup ("ArrayShape: Invalid shape with zero Rank");
        vinfo->info.message = D.22172;
        vinfo->exception_type = 3;
        D.22164 = ctx->errors;
        D.22173 = monoeg_g_slist_prepend (D.22164, vinfo);
        ctx->errors = D.22173;
      }
      <D.22171>:
      ctx->valid = 0;
      D.22166 = 0;
      return D.22166;
      <D.22169>:
      D.22174 = safe_read_compressed_int (&ptr, end, &size);
      if (D.22174 == 0) goto <D.22175>; else goto <D.22176>;
      <D.22175>:
      D.22160 = ctx->report_error;
      if (D.22160 != 0) goto <D.22177>; else goto <D.22178>;
      <D.22177>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22179 = monoeg_strdup ("ArrayShape: Not enough room for NumSizes");
        vinfo->info.message = D.22179;
        vinfo->exception_type = 3;
        D.22164 = ctx->errors;
        D.22180 = monoeg_g_slist_prepend (D.22164, vinfo);
        ctx->errors = D.22180;
      }
      <D.22178>:
      ctx->valid = 0;
      D.22166 = 0;
      return D.22166;
      <D.22176>:
      i = 0;
      goto <D.17852>;
      <D.17851>:
      D.22181 = safe_read_compressed_int (&ptr, end, &num);
      if (D.22181 == 0) goto <D.22182>; else goto <D.22183>;
      <D.22182>:
      D.22160 = ctx->report_error;
      if (D.22160 != 0) goto <D.22184>; else goto <D.22185>;
      <D.22184>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22186 = i + 1;
        D.22187 = monoeg_g_strdup_printf ("ArrayShape: Not enough room for Size of rank %d", D.22186);
        vinfo->info.message = D.22187;
        vinfo->exception_type = 3;
        D.22164 = ctx->errors;
        D.22188 = monoeg_g_slist_prepend (D.22164, vinfo);
        ctx->errors = D.22188;
      }
      <D.22185>:
      ctx->valid = 0;
      D.22166 = 0;
      return D.22166;
      <D.22183>:
      i = i + 1;
      <D.17852>:
      size.78 = size;
      if (i < size.78) goto <D.17851>; else goto <D.17853>;
      <D.17853>:
      D.22190 = safe_read_compressed_int (&ptr, end, &size);
      if (D.22190 == 0) goto <D.22191>; else goto <D.22192>;
      <D.22191>:
      D.22160 = ctx->report_error;
      if (D.22160 != 0) goto <D.22193>; else goto <D.22194>;
      <D.22193>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22195 = monoeg_strdup ("ArrayShape: Not enough room for NumLoBounds");
        vinfo->info.message = D.22195;
        vinfo->exception_type = 3;
        D.22164 = ctx->errors;
        D.22196 = monoeg_g_slist_prepend (D.22164, vinfo);
        ctx->errors = D.22196;
      }
      <D.22194>:
      ctx->valid = 0;
      D.22166 = 0;
      return D.22166;
      <D.22192>:
      i = 0;
      goto <D.17857>;
      <D.17856>:
      D.22197 = safe_read_compressed_int (&ptr, end, &num);
      if (D.22197 == 0) goto <D.22198>; else goto <D.22199>;
      <D.22198>:
      D.22160 = ctx->report_error;
      if (D.22160 != 0) goto <D.22200>; else goto <D.22201>;
      <D.22200>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22186 = i + 1;
        D.22202 = monoeg_g_strdup_printf ("ArrayShape: Not enough room for LoBound of rank %d", D.22186);
        vinfo->info.message = D.22202;
        vinfo->exception_type = 3;
        D.22164 = ctx->errors;
        D.22203 = monoeg_g_slist_prepend (D.22164, vinfo);
        ctx->errors = D.22203;
      }
      <D.22201>:
      ctx->valid = 0;
      D.22166 = 0;
      return D.22166;
      <D.22199>:
      i = i + 1;
      <D.17857>:
      size.78 = size;
      if (i < size.78) goto <D.17856>; else goto <D.17858>;
      <D.17858>:
      ptr.79 = ptr;
      *_ptr = ptr.79;
      D.22166 = 1;
      return D.22166;
    }
  finally
    {
      ptr = {CLOBBER};
      val = {CLOBBER};
      size = {CLOBBER};
      num = {CLOBBER};
    }
}


parse_generic_inst (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.80;
  int D.22208;
  int D.22211;
  gchar * D.22214;
  struct GSList * D.22215;
  struct GSList * D.22216;
  gboolean D.22217;
  unsigned int type.81;
  unsigned int D.22219;
  gchar * D.22224;
  struct GSList * D.22225;
  int D.22226;
  gchar * D.22231;
  struct GSList * D.22232;
  unsigned int token.82;
  int D.22236;
  unsigned int D.22238;
  gchar * D.22241;
  struct GSList * D.22242;
  unsigned int D.22243;
  unsigned int D.22246;
  unsigned int D.22247;
  unsigned int D.22250;
  unsigned int D.22251;
  gchar * D.22256;
  struct GSList * D.22257;
  int D.22258;
  gchar * D.22263;
  struct GSList * D.22264;
  unsigned int count.83;
  gchar * D.22270;
  struct GSList * D.22271;
  int D.22272;
  gchar * D.22277;
  struct GSList * D.22278;
  int D.22279;
  unsigned int D.22284;
  gchar * D.22285;
  struct GSList * D.22286;
  const char * ptr.84;
  const char * ptr;
  unsigned int type;
  unsigned int count;
  unsigned int token;
  unsigned int i;

  try
    {
      ptr.80 = *_ptr;
      ptr = ptr.80;
      D.22208 = safe_read (&ptr, end, &type, 1);
      if (D.22208 == 0) goto <D.22209>; else goto <D.22210>;
      <D.22209>:
      D.22211 = ctx->report_error;
      if (D.22211 != 0) goto <D.22212>; else goto <D.22213>;
      <D.22212>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22214 = monoeg_strdup ("GenericInst: Not enough room for kind");
        vinfo->info.message = D.22214;
        vinfo->exception_type = 3;
        D.22215 = ctx->errors;
        D.22216 = monoeg_g_slist_prepend (D.22215, vinfo);
        ctx->errors = D.22216;
      }
      <D.22213>:
      ctx->valid = 0;
      D.22217 = 0;
      return D.22217;
      <D.22210>:
      type.81 = type;
      D.22219 = type.81 + 4294967279;
      if (D.22219 > 1) goto <D.22220>; else goto <D.22221>;
      <D.22220>:
      D.22211 = ctx->report_error;
      if (D.22211 != 0) goto <D.22222>; else goto <D.22223>;
      <D.22222>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        type.81 = type;
        D.22224 = monoeg_g_strdup_printf ("GenericInst: Invalid GenericInst kind %x\n", type.81);
        vinfo->info.message = D.22224;
        vinfo->exception_type = 3;
        D.22215 = ctx->errors;
        D.22225 = monoeg_g_slist_prepend (D.22215, vinfo);
        ctx->errors = D.22225;
      }
      <D.22223>:
      ctx->valid = 0;
      D.22217 = 0;
      return D.22217;
      <D.22221>:
      D.22226 = safe_read_compressed_int (&ptr, end, &token);
      if (D.22226 == 0) goto <D.22227>; else goto <D.22228>;
      <D.22227>:
      D.22211 = ctx->report_error;
      if (D.22211 != 0) goto <D.22229>; else goto <D.22230>;
      <D.22229>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22231 = monoeg_strdup ("GenericInst: Not enough room for type token");
        vinfo->info.message = D.22231;
        vinfo->exception_type = 3;
        D.22215 = ctx->errors;
        D.22232 = monoeg_g_slist_prepend (D.22215, vinfo);
        ctx->errors = D.22232;
      }
      <D.22230>:
      ctx->valid = 0;
      D.22217 = 0;
      return D.22217;
      <D.22228>:
      token.82 = token;
      D.22236 = is_valid_coded_index (ctx, 0, token.82);
      if (D.22236 == 0) goto <D.22233>; else goto <D.22237>;
      <D.22237>:
      token.82 = token;
      D.22238 = get_coded_index_token (0, token.82);
      if (D.22238 == 0) goto <D.22233>; else goto <D.22234>;
      <D.22233>:
      D.22211 = ctx->report_error;
      if (D.22211 != 0) goto <D.22239>; else goto <D.22240>;
      <D.22239>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        token.82 = token;
        D.22241 = monoeg_g_strdup_printf ("GenericInst: invalid TypeDefOrRef token %x", token.82);
        vinfo->info.message = D.22241;
        vinfo->exception_type = 3;
        D.22215 = ctx->errors;
        D.22242 = monoeg_g_slist_prepend (D.22215, vinfo);
        ctx->errors = D.22242;
      }
      <D.22240>:
      ctx->valid = 0;
      D.22217 = 0;
      return D.22217;
      <D.22234>:
      D.22243 = ctx->token;
      if (D.22243 != 0) goto <D.22244>; else goto <D.22245>;
      <D.22244>:
      D.22243 = ctx->token;
      D.22246 = D.22243 & 16777215;
      token.82 = token;
      D.22247 = get_coded_index_token (0, token.82);
      if (D.22246 == D.22247) goto <D.22248>; else goto <D.22249>;
      <D.22248>:
      D.22243 = ctx->token;
      D.22250 = D.22243 >> 24;
      token.82 = token;
      D.22251 = get_coded_index_table (0, token.82);
      if (D.22250 == D.22251) goto <D.22252>; else goto <D.22253>;
      <D.22252>:
      D.22211 = ctx->report_error;
      if (D.22211 != 0) goto <D.22254>; else goto <D.22255>;
      <D.22254>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22243 = ctx->token;
        D.22256 = monoeg_g_strdup_printf ("Type: Recurside generic instance specification (%x). A type signature can\'t reference itself", D.22243);
        vinfo->info.message = D.22256;
        vinfo->exception_type = 3;
        D.22215 = ctx->errors;
        D.22257 = monoeg_g_slist_prepend (D.22215, vinfo);
        ctx->errors = D.22257;
      }
      <D.22255>:
      ctx->valid = 0;
      D.22217 = 0;
      return D.22217;
      <D.22253>:
      <D.22249>:
      <D.22245>:
      D.22258 = safe_read_compressed_int (&ptr, end, &count);
      if (D.22258 == 0) goto <D.22259>; else goto <D.22260>;
      <D.22259>:
      D.22211 = ctx->report_error;
      if (D.22211 != 0) goto <D.22261>; else goto <D.22262>;
      <D.22261>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22263 = monoeg_strdup ("GenericInst: Not enough room for argument count");
        vinfo->info.message = D.22263;
        vinfo->exception_type = 3;
        D.22215 = ctx->errors;
        D.22264 = monoeg_g_slist_prepend (D.22215, vinfo);
        ctx->errors = D.22264;
      }
      <D.22262>:
      ctx->valid = 0;
      D.22217 = 0;
      return D.22217;
      <D.22260>:
      count.83 = count;
      if (count.83 == 0) goto <D.22266>; else goto <D.22267>;
      <D.22266>:
      D.22211 = ctx->report_error;
      if (D.22211 != 0) goto <D.22268>; else goto <D.22269>;
      <D.22268>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22270 = monoeg_strdup ("GenericInst: Zero arguments generic instance");
        vinfo->info.message = D.22270;
        vinfo->exception_type = 3;
        D.22215 = ctx->errors;
        D.22271 = monoeg_g_slist_prepend (D.22215, vinfo);
        ctx->errors = D.22271;
      }
      <D.22269>:
      ctx->valid = 0;
      D.22217 = 0;
      return D.22217;
      <D.22267>:
      i = 0;
      goto <D.17879>;
      <D.17878>:
      D.22272 = parse_custom_mods (ctx, &ptr, end);
      if (D.22272 == 0) goto <D.22273>; else goto <D.22274>;
      <D.22273>:
      D.22211 = ctx->report_error;
      if (D.22211 != 0) goto <D.22275>; else goto <D.22276>;
      <D.22275>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22277 = monoeg_strdup ("Type: Failed to parse pointer custom attr");
        vinfo->info.message = D.22277;
        vinfo->exception_type = 3;
        D.22215 = ctx->errors;
        D.22278 = monoeg_g_slist_prepend (D.22215, vinfo);
        ctx->errors = D.22278;
      }
      <D.22276>:
      ctx->valid = 0;
      D.22217 = 0;
      return D.22217;
      <D.22274>:
      D.22279 = parse_type (ctx, &ptr, end);
      if (D.22279 == 0) goto <D.22280>; else goto <D.22281>;
      <D.22280>:
      D.22211 = ctx->report_error;
      if (D.22211 != 0) goto <D.22282>; else goto <D.22283>;
      <D.22282>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22284 = i + 1;
        D.22285 = monoeg_g_strdup_printf ("GenericInst: invalid generic argument %d", D.22284);
        vinfo->info.message = D.22285;
        vinfo->exception_type = 3;
        D.22215 = ctx->errors;
        D.22286 = monoeg_g_slist_prepend (D.22215, vinfo);
        ctx->errors = D.22286;
      }
      <D.22283>:
      ctx->valid = 0;
      D.22217 = 0;
      return D.22217;
      <D.22281>:
      i = i + 1;
      <D.17879>:
      count.83 = count;
      if (i < count.83) goto <D.17878>; else goto <D.17880>;
      <D.17880>:
      ptr.84 = ptr;
      *_ptr = ptr.84;
      D.22217 = 1;
      return D.22217;
    }
  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.85;
  int D.22291;
  int D.22294;
  gchar * D.22297;
  struct GSList * D.22298;
  struct GSList * D.22299;
  gboolean D.22300;
  unsigned int cconv.86;
  unsigned int D.22302;
  gchar * D.22307;
  struct GSList * D.22308;
  unsigned int D.22311;
  gchar * D.22316;
  struct GSList * D.22317;
  gchar * D.22325;
  struct GSList * D.22326;
  unsigned int D.22327;
  int D.22330;
  gchar * D.22335;
  struct GSList * D.22336;
  unsigned int gparam_count.87;
  gchar * D.22344;
  struct GSList * D.22345;
  gchar * D.22352;
  struct GSList * D.22353;
  int D.22354;
  gchar * D.22359;
  struct GSList * D.22360;
  int D.22361;
  gchar * D.22366;
  struct GSList * D.22367;
  int D.22370;
  gchar * D.22375;
  struct GSList * D.22376;
  unsigned int type.88;
  gchar * D.22384;
  struct GSList * D.22385;
  gchar * D.22390;
  struct GSList * D.22391;
  const char * ptr.89;
  const char * ptr.90;
  int D.22395;
  gchar * D.22400;
  struct GSList * D.22401;
  unsigned int param_count.91;
  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.85 = *_ptr;
      ptr = ptr.85;
      saw_sentinel = 0;
      D.22291 = safe_read (&ptr, end, &cconv, 1);
      if (D.22291 == 0) goto <D.22292>; else goto <D.22293>;
      <D.22292>:
      D.22294 = ctx->report_error;
      if (D.22294 != 0) goto <D.22295>; else goto <D.22296>;
      <D.22295>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22297 = monoeg_strdup ("MethodSig: Not enough room for the call conv");
        vinfo->info.message = D.22297;
        vinfo->exception_type = 3;
        D.22298 = ctx->errors;
        D.22299 = monoeg_g_slist_prepend (D.22298, vinfo);
        ctx->errors = D.22299;
      }
      <D.22296>:
      ctx->valid = 0;
      D.22300 = 0;
      return D.22300;
      <D.22293>:
      cconv.86 = cconv;
      D.22302 = cconv.86 & 128;
      if (D.22302 != 0) goto <D.22303>; else goto <D.22304>;
      <D.22303>:
      D.22294 = ctx->report_error;
      if (D.22294 != 0) goto <D.22305>; else goto <D.22306>;
      <D.22305>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22307 = monoeg_strdup ("MethodSig: CallConv has 0x80 set");
        vinfo->info.message = D.22307;
        vinfo->exception_type = 3;
        D.22298 = ctx->errors;
        D.22308 = monoeg_g_slist_prepend (D.22298, vinfo);
        ctx->errors = D.22308;
      }
      <D.22306>:
      ctx->valid = 0;
      D.22300 = 0;
      return D.22300;
      <D.22304>:
      if (allow_unmanaged != 0) goto <D.22309>; else goto <D.22310>;
      <D.22309>:
      cconv.86 = cconv;
      D.22311 = cconv.86 & 15;
      if (D.22311 > 5) goto <D.22312>; else goto <D.22313>;
      <D.22312>:
      D.22294 = ctx->report_error;
      if (D.22294 != 0) goto <D.22314>; else goto <D.22315>;
      <D.22314>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        cconv.86 = cconv;
        D.22311 = cconv.86 & 15;
        D.22316 = monoeg_g_strdup_printf ("MethodSig: CallConv is not valid, it\'s %x", D.22311);
        vinfo->info.message = D.22316;
        vinfo->exception_type = 3;
        D.22298 = ctx->errors;
        D.22317 = monoeg_g_slist_prepend (D.22298, vinfo);
        ctx->errors = D.22317;
      }
      <D.22315>:
      ctx->valid = 0;
      D.22300 = 0;
      return D.22300;
      <D.22313>:
      goto <D.22318>;
      <D.22310>:
      cconv.86 = cconv;
      D.22311 = cconv.86 & 15;
      if (D.22311 != 0) goto <D.22319>; else goto <D.22320>;
      <D.22319>:
      cconv.86 = cconv;
      D.22311 = cconv.86 & 15;
      if (D.22311 != 5) goto <D.22321>; else goto <D.22322>;
      <D.22321>:
      D.22294 = ctx->report_error;
      if (D.22294 != 0) goto <D.22323>; else goto <D.22324>;
      <D.22323>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        cconv.86 = cconv;
        D.22311 = cconv.86 & 15;
        D.22325 = monoeg_g_strdup_printf ("MethodSig: CallConv is not Default or Vararg, it\'s %x", D.22311);
        vinfo->info.message = D.22325;
        vinfo->exception_type = 3;
        D.22298 = ctx->errors;
        D.22326 = monoeg_g_slist_prepend (D.22298, vinfo);
        ctx->errors = D.22326;
      }
      <D.22324>:
      ctx->valid = 0;
      D.22300 = 0;
      return D.22300;
      <D.22322>:
      <D.22320>:
      <D.22318>:
      cconv.86 = cconv;
      D.22327 = cconv.86 & 16;
      if (D.22327 != 0) goto <D.22328>; else goto <D.22329>;
      <D.22328>:
      D.22330 = safe_read_compressed_int (&ptr, end, &gparam_count);
      if (D.22330 == 0) goto <D.22331>; else goto <D.22332>;
      <D.22331>:
      D.22294 = ctx->report_error;
      if (D.22294 != 0) goto <D.22333>; else goto <D.22334>;
      <D.22333>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22335 = monoeg_strdup ("MethodSig: Not enough room for the generic param count");
        vinfo->info.message = D.22335;
        vinfo->exception_type = 3;
        D.22298 = ctx->errors;
        D.22336 = monoeg_g_slist_prepend (D.22298, vinfo);
        ctx->errors = D.22336;
      }
      <D.22334>:
      ctx->valid = 0;
      D.22300 = 0;
      return D.22300;
      <D.22332>:
      <D.22329>:
      cconv.86 = cconv;
      D.22327 = cconv.86 & 16;
      if (D.22327 != 0) goto <D.22337>; else goto <D.22338>;
      <D.22337>:
      gparam_count.87 = gparam_count;
      if (gparam_count.87 == 0) goto <D.22340>; else goto <D.22341>;
      <D.22340>:
      D.22294 = ctx->report_error;
      if (D.22294 != 0) goto <D.22342>; else goto <D.22343>;
      <D.22342>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22344 = monoeg_strdup ("MethodSig: Signature with generics but zero arity");
        vinfo->info.message = D.22344;
        vinfo->exception_type = 3;
        D.22298 = ctx->errors;
        D.22345 = monoeg_g_slist_prepend (D.22298, vinfo);
        ctx->errors = D.22345;
      }
      <D.22343>:
      ctx->valid = 0;
      D.22300 = 0;
      return D.22300;
      <D.22341>:
      <D.22338>:
      if (allow_unmanaged != 0) goto <D.22346>; else goto <D.22347>;
      <D.22346>:
      cconv.86 = cconv;
      D.22327 = cconv.86 & 16;
      if (D.22327 != 0) goto <D.22348>; else goto <D.22349>;
      <D.22348>:
      D.22294 = ctx->report_error;
      if (D.22294 != 0) goto <D.22350>; else goto <D.22351>;
      <D.22350>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22352 = monoeg_strdup ("MethodSig: Standalone signature with generic params");
        vinfo->info.message = D.22352;
        vinfo->exception_type = 3;
        D.22298 = ctx->errors;
        D.22353 = monoeg_g_slist_prepend (D.22298, vinfo);
        ctx->errors = D.22353;
      }
      <D.22351>:
      ctx->valid = 0;
      D.22300 = 0;
      return D.22300;
      <D.22349>:
      <D.22347>:
      D.22354 = safe_read_compressed_int (&ptr, end, &param_count);
      if (D.22354 == 0) goto <D.22355>; else goto <D.22356>;
      <D.22355>:
      D.22294 = ctx->report_error;
      if (D.22294 != 0) goto <D.22357>; else goto <D.22358>;
      <D.22357>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22359 = monoeg_strdup ("MethodSig: Not enough room for the param count");
        vinfo->info.message = D.22359;
        vinfo->exception_type = 3;
        D.22298 = ctx->errors;
        D.22360 = monoeg_g_slist_prepend (D.22298, vinfo);
        ctx->errors = D.22360;
      }
      <D.22358>:
      ctx->valid = 0;
      D.22300 = 0;
      return D.22300;
      <D.22356>:
      D.22361 = parse_return_type (ctx, &ptr, end);
      if (D.22361 == 0) goto <D.22362>; else goto <D.22363>;
      <D.22362>:
      D.22294 = ctx->report_error;
      if (D.22294 != 0) goto <D.22364>; else goto <D.22365>;
      <D.22364>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22366 = monoeg_strdup ("MethodSig: Error parsing return type");
        vinfo->info.message = D.22366;
        vinfo->exception_type = 3;
        D.22298 = ctx->errors;
        D.22367 = monoeg_g_slist_prepend (D.22298, vinfo);
        ctx->errors = D.22367;
      }
      <D.22365>:
      ctx->valid = 0;
      D.22300 = 0;
      return D.22300;
      <D.22363>:
      i = 0;
      goto <D.17959>;
      <D.17958>:
      if (allow_sentinel != 0) goto <D.22368>; else goto <D.22369>;
      <D.22368>:
      D.22370 = safe_read (&ptr, end, &type, 1);
      if (D.22370 == 0) goto <D.22371>; else goto <D.22372>;
      <D.22371>:
      D.22294 = ctx->report_error;
      if (D.22294 != 0) goto <D.22373>; else goto <D.22374>;
      <D.22373>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22375 = monoeg_g_strdup_printf ("MethodSig: Not enough room for param %d type", i);
        vinfo->info.message = D.22375;
        vinfo->exception_type = 3;
        D.22298 = ctx->errors;
        D.22376 = monoeg_g_slist_prepend (D.22298, vinfo);
        ctx->errors = D.22376;
      }
      <D.22374>:
      ctx->valid = 0;
      D.22300 = 0;
      return D.22300;
      <D.22372>:
      type.88 = type;
      if (type.88 == 65) goto <D.22378>; else goto <D.22379>;
      <D.22378>:
      cconv.86 = cconv;
      D.22311 = cconv.86 & 15;
      if (D.22311 != 5) goto <D.22380>; else goto <D.22381>;
      <D.22380>:
      D.22294 = ctx->report_error;
      if (D.22294 != 0) goto <D.22382>; else goto <D.22383>;
      <D.22382>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22384 = monoeg_strdup ("MethodSig: Found sentinel but signature is not vararg");
        vinfo->info.message = D.22384;
        vinfo->exception_type = 3;
        D.22298 = ctx->errors;
        D.22385 = monoeg_g_slist_prepend (D.22298, vinfo);
        ctx->errors = D.22385;
      }
      <D.22383>:
      ctx->valid = 0;
      D.22300 = 0;
      return D.22300;
      <D.22381>:
      if (saw_sentinel != 0) goto <D.22386>; else goto <D.22387>;
      <D.22386>:
      D.22294 = ctx->report_error;
      if (D.22294 != 0) goto <D.22388>; else goto <D.22389>;
      <D.22388>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22390 = monoeg_strdup ("MethodSig: More than one sentinel type");
        vinfo->info.message = D.22390;
        vinfo->exception_type = 3;
        D.22298 = ctx->errors;
        D.22391 = monoeg_g_slist_prepend (D.22298, vinfo);
        ctx->errors = D.22391;
      }
      <D.22389>:
      ctx->valid = 0;
      D.22300 = 0;
      return D.22300;
      <D.22387>:
      saw_sentinel = 1;
      goto <D.22392>;
      <D.22379>:
      ptr.89 = ptr;
      ptr.90 = ptr.89 + 4294967295;
      ptr = ptr.90;
      <D.22392>:
      <D.22369>:
      D.22395 = parse_param (ctx, &ptr, end);
      if (D.22395 == 0) goto <D.22396>; else goto <D.22397>;
      <D.22396>:
      D.22294 = ctx->report_error;
      if (D.22294 != 0) goto <D.22398>; else goto <D.22399>;
      <D.22398>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22400 = monoeg_g_strdup_printf ("MethodSig: Error parsing arg %d", i);
        vinfo->info.message = D.22400;
        vinfo->exception_type = 3;
        D.22298 = ctx->errors;
        D.22401 = monoeg_g_slist_prepend (D.22298, vinfo);
        ctx->errors = D.22401;
      }
      <D.22399>:
      ctx->valid = 0;
      D.22300 = 0;
      return D.22300;
      <D.22397>:
      i = i + 1;
      <D.17959>:
      param_count.91 = param_count;
      if (i < param_count.91) goto <D.17958>; else goto <D.17960>;
      <D.17960>:
      ptr.89 = ptr;
      *_ptr = ptr.89;
      D.22300 = 1;
      return D.22300;
    }
  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.22405;
  gboolean D.22408;
  const char * ptr.92;
  int D.22410;
  int D.22413;
  gchar * D.22416;
  struct GSList * D.22417;
  struct GSList * D.22418;
  unsigned int type.93;
  const char * ptr.94;
  const char * ptr;
  unsigned int type;

  try
    {
      type = 0;
      D.22405 = parse_custom_mods (ctx, _ptr, end);
      if (D.22405 == 0) goto <D.22406>; else goto <D.22407>;
      <D.22406>:
      D.22408 = 0;
      return D.22408;
      <D.22407>:
      ptr.92 = *_ptr;
      ptr = ptr.92;
      D.22410 = safe_read (&ptr, end, &type, 1);
      if (D.22410 == 0) goto <D.22411>; else goto <D.22412>;
      <D.22411>:
      D.22413 = ctx->report_error;
      if (D.22413 != 0) goto <D.22414>; else goto <D.22415>;
      <D.22414>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22416 = monoeg_strdup ("ReturnType: Not enough room for the type");
        vinfo->info.message = D.22416;
        vinfo->exception_type = 3;
        D.22417 = ctx->errors;
        D.22418 = monoeg_g_slist_prepend (D.22417, vinfo);
        ctx->errors = D.22418;
      }
      <D.22415>:
      ctx->valid = 0;
      D.22408 = 0;
      return D.22408;
      <D.22412>:
      type.93 = type;
      if (type.93 == 1) goto <D.22419>; else goto <D.22422>;
      <D.22422>:
      type.93 = type;
      if (type.93 == 22) goto <D.22419>; else goto <D.22420>;
      <D.22419>:
      ptr.94 = ptr;
      *_ptr = ptr.94;
      D.22408 = 1;
      return D.22408;
      <D.22420>:
      type.93 = type;
      if (type.93 == 16) goto <D.22424>; else goto <D.22425>;
      <D.22424>:
      ptr.94 = ptr;
      *_ptr = ptr.94;
      <D.22425>:
      D.22408 = parse_type (ctx, _ptr, end);
      return D.22408;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
    }
}


parse_param (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  int D.22428;
  gboolean D.22431;
  const char * ptr.95;
  int D.22433;
  int D.22436;
  gchar * D.22439;
  struct GSList * D.22440;
  struct GSList * D.22441;
  unsigned int type.96;
  const char * ptr.97;
  int D.22448;
  const char * ptr;
  unsigned int type;

  try
    {
      type = 0;
      D.22428 = parse_custom_mods (ctx, _ptr, end);
      if (D.22428 == 0) goto <D.22429>; else goto <D.22430>;
      <D.22429>:
      D.22431 = 0;
      return D.22431;
      <D.22430>:
      ptr.95 = *_ptr;
      ptr = ptr.95;
      D.22433 = safe_read (&ptr, end, &type, 1);
      if (D.22433 == 0) goto <D.22434>; else goto <D.22435>;
      <D.22434>:
      D.22436 = ctx->report_error;
      if (D.22436 != 0) goto <D.22437>; else goto <D.22438>;
      <D.22437>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22439 = monoeg_strdup ("Param: Not enough room for the type");
        vinfo->info.message = D.22439;
        vinfo->exception_type = 3;
        D.22440 = ctx->errors;
        D.22441 = monoeg_g_slist_prepend (D.22440, vinfo);
        ctx->errors = D.22441;
      }
      <D.22438>:
      ctx->valid = 0;
      D.22431 = 0;
      return D.22431;
      <D.22435>:
      type.96 = type;
      if (type.96 == 22) goto <D.22443>; else goto <D.22444>;
      <D.22443>:
      ptr.97 = ptr;
      *_ptr = ptr.97;
      D.22431 = 1;
      return D.22431;
      <D.22444>:
      type.96 = type;
      if (type.96 == 16) goto <D.22446>; else goto <D.22447>;
      <D.22446>:
      ptr.97 = ptr;
      *_ptr = ptr.97;
      D.22448 = parse_custom_mods (ctx, _ptr, end);
      if (D.22448 == 0) goto <D.22449>; else goto <D.22450>;
      <D.22449>:
      D.22431 = 0;
      return D.22431;
      <D.22450>:
      <D.22447>:
      D.22431 = parse_type (ctx, _ptr, end);
      return D.22431;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
    }
}


verify_methodimpl_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22453;
  unsigned int D.22456;
  <unnamed-unsigned:24> D.22458;
  int D.22459;
  int D.22460;
  unsigned int D.22461;
  int D.22462;
  unsigned int D.22465;
  gchar * D.22466;
  struct GSList * D.22467;
  struct GSList * D.22468;
  unsigned int D.22469;
  unsigned int D.22470;
  gchar * D.22475;
  struct GSList * D.22476;
  int D.22477;
  gchar * D.22482;
  struct GSList * D.22483;
  unsigned int D.22484;
  gchar * D.22489;
  struct GSList * D.22490;
  int D.22491;
  gchar * D.22496;
  struct GSList * D.22497;
  <unnamed-unsigned:24> D.22498;
  int D.22499;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.22453 = ctx->image;
      table = &D.22453->tables[25];
      i = 0;
      goto <D.18808>;
      <D.18807>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.22456 = data[0];
      if (D.22456 == 0) goto <D.22454>; else goto <D.22457>;
      <D.22457>:
      D.22456 = data[0];
      D.22453 = ctx->image;
      D.22458 = D.22453->tables[2].rows;
      D.22459 = (int) D.22458;
      D.22460 = D.22459 + 1;
      D.22461 = (unsigned int) D.22460;
      if (D.22456 > D.22461) goto <D.22454>; else goto <D.22455>;
      <D.22454>:
      D.22462 = ctx->report_error;
      if (D.22462 != 0) goto <D.22463>; else goto <D.22464>;
      <D.22463>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22465 = data[2];
        D.22466 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d Class field %08x", i, D.22465);
        vinfo->info.message = D.22466;
        vinfo->exception_type = 3;
        D.22467 = ctx->errors;
        D.22468 = monoeg_g_slist_prepend (D.22467, vinfo);
        ctx->errors = D.22468;
      }
      <D.22464>:
      ctx->valid = 0;
      return;
      <D.22455>:
      D.22469 = data[1];
      D.22470 = get_coded_index_token (52, D.22469);
      if (D.22470 == 0) goto <D.22471>; else goto <D.22472>;
      <D.22471>:
      D.22462 = ctx->report_error;
      if (D.22462 != 0) goto <D.22473>; else goto <D.22474>;
      <D.22473>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22469 = data[1];
        D.22475 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodBody field %08x", i, D.22469);
        vinfo->info.message = D.22475;
        vinfo->exception_type = 3;
        D.22467 = ctx->errors;
        D.22476 = monoeg_g_slist_prepend (D.22467, vinfo);
        ctx->errors = D.22476;
      }
      <D.22474>:
      ctx->valid = 0;
      return;
      <D.22472>:
      D.22469 = data[1];
      D.22477 = is_valid_coded_index (ctx, 52, D.22469);
      if (D.22477 == 0) goto <D.22478>; else goto <D.22479>;
      <D.22478>:
      D.22462 = ctx->report_error;
      if (D.22462 != 0) goto <D.22480>; else goto <D.22481>;
      <D.22480>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22469 = data[1];
        D.22482 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodBody field %08x", i, D.22469);
        vinfo->info.message = D.22482;
        vinfo->exception_type = 3;
        D.22467 = ctx->errors;
        D.22483 = monoeg_g_slist_prepend (D.22467, vinfo);
        ctx->errors = D.22483;
      }
      <D.22481>:
      ctx->valid = 0;
      return;
      <D.22479>:
      D.22465 = data[2];
      D.22484 = get_coded_index_token (52, D.22465);
      if (D.22484 == 0) goto <D.22485>; else goto <D.22486>;
      <D.22485>:
      D.22462 = ctx->report_error;
      if (D.22462 != 0) goto <D.22487>; else goto <D.22488>;
      <D.22487>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22465 = data[2];
        D.22489 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodDeclaration field %08x", i, D.22465);
        vinfo->info.message = D.22489;
        vinfo->exception_type = 3;
        D.22467 = ctx->errors;
        D.22490 = monoeg_g_slist_prepend (D.22467, vinfo);
        ctx->errors = D.22490;
      }
      <D.22488>:
      ctx->valid = 0;
      return;
      <D.22486>:
      D.22465 = data[2];
      D.22491 = is_valid_coded_index (ctx, 52, D.22465);
      if (D.22491 == 0) goto <D.22492>; else goto <D.22493>;
      <D.22492>:
      D.22462 = ctx->report_error;
      if (D.22462 != 0) goto <D.22494>; else goto <D.22495>;
      <D.22494>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22465 = data[2];
        D.22496 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodDeclaration field %08x", i, D.22465);
        vinfo->info.message = D.22496;
        vinfo->exception_type = 3;
        D.22467 = ctx->errors;
        D.22497 = monoeg_g_slist_prepend (D.22467, vinfo);
        ctx->errors = D.22497;
      }
      <D.22495>:
      ctx->valid = 0;
      return;
      <D.22493>:
      i = i + 1;
      <D.18808>:
      D.22498 = table->rows;
      D.22499 = (int) D.22498;
      if (D.22499 > i) goto <D.18807>; else goto <D.18809>;
      <D.18809>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_moduleref_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22503;
  unsigned int D.22504;
  int D.22505;
  int D.22508;
  gchar * D.22511;
  struct GSList * D.22512;
  struct GSList * D.22513;
  <unnamed-unsigned:24> D.22514;
  int D.22515;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.22503 = ctx->image;
      table = &D.22503->tables[26];
      i = 0;
      goto <D.18818>;
      <D.18817>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.22504 = data[0];
      D.22505 = is_valid_non_empty_string (ctx, D.22504);
      if (D.22505 == 0) goto <D.22506>; else goto <D.22507>;
      <D.22506>:
      D.22508 = ctx->report_error;
      if (D.22508 != 0) goto <D.22509>; else goto <D.22510>;
      <D.22509>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22504 = data[0];
        D.22511 = monoeg_g_strdup_printf ("Invalid ModuleRef row %d name field %08x", i, D.22504);
        vinfo->info.message = D.22511;
        vinfo->exception_type = 3;
        D.22512 = ctx->errors;
        D.22513 = monoeg_g_slist_prepend (D.22512, vinfo);
        ctx->errors = D.22513;
      }
      <D.22510>:
      ctx->valid = 0;
      return;
      <D.22507>:
      i = i + 1;
      <D.18818>:
      D.22514 = table->rows;
      D.22515 = (int) D.22514;
      if (D.22515 > i) goto <D.18817>; else goto <D.18819>;
      <D.18819>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_typespec_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22519;
  unsigned int D.22520;
  int D.22523;
  int D.22526;
  gchar * D.22529;
  struct GSList * D.22530;
  struct GSList * D.22531;
  <unnamed-unsigned:24> D.22532;
  int D.22533;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.22519 = ctx->image;
      table = &D.22519->tables[27];
      i = 0;
      goto <D.18828>;
      <D.18827>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.22520 = data[0];
      if (D.22520 != 0) goto <D.22521>; else goto <D.22522>;
      <D.22521>:
      D.22520 = data[0];
      D.22523 = is_valid_blob_object (ctx, D.22520, 1);
      if (D.22523 == 0) goto <D.22524>; else goto <D.22525>;
      <D.22524>:
      D.22526 = ctx->report_error;
      if (D.22526 != 0) goto <D.22527>; else goto <D.22528>;
      <D.22527>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22520 = data[0];
        D.22529 = monoeg_g_strdup_printf ("Invalid TypeSpec row %d Signature field %08x", i, D.22520);
        vinfo->info.message = D.22529;
        vinfo->exception_type = 3;
        D.22530 = ctx->errors;
        D.22531 = monoeg_g_slist_prepend (D.22530, vinfo);
        ctx->errors = D.22531;
      }
      <D.22528>:
      ctx->valid = 0;
      return;
      <D.22525>:
      <D.22522>:
      i = i + 1;
      <D.18828>:
      D.22532 = table->rows;
      D.22533 = (int) D.22532;
      if (D.22533 > i) goto <D.18827>; else goto <D.18829>;
      <D.18829>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_implmap_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22537;
  unsigned int D.22538;
  unsigned int D.22539;
  int D.22542;
  gchar * D.22545;
  struct GSList * D.22546;
  struct GSList * D.22547;
  gchar * D.22554;
  struct GSList * D.22555;
  unsigned int D.22556;
  int D.22557;
  gchar * D.22562;
  struct GSList * D.22563;
  unsigned int D.22564;
  gchar * D.22569;
  struct GSList * D.22570;
  unsigned int D.22571;
  gchar * D.22576;
  struct GSList * D.22577;
  unsigned int D.22578;
  int D.22579;
  gchar * D.22584;
  struct GSList * D.22585;
  unsigned int D.22588;
  <unnamed-unsigned:24> D.22590;
  unsigned int D.22591;
  gchar * D.22594;
  struct GSList * D.22595;
  <unnamed-unsigned:24> D.22596;
  int D.22597;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 cconv;
  int i;

  try
    {
      D.22537 = ctx->image;
      table = &D.22537->tables[28];
      i = 0;
      goto <D.18855>;
      <D.18854>:
      mono_metadata_decode_row (table, i, &data, 4);
      D.22538 = data[0];
      D.22539 = D.22538 & 4294953096;
      if (D.22539 != 0) goto <D.22540>; else goto <D.22541>;
      <D.22540>:
      D.22542 = ctx->report_error;
      if (D.22542 != 0) goto <D.22543>; else goto <D.22544>;
      <D.22543>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22538 = data[0];
        D.22545 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Flags field %08x", i, D.22538);
        vinfo->info.message = D.22545;
        vinfo->exception_type = 3;
        D.22546 = ctx->errors;
        D.22547 = monoeg_g_slist_prepend (D.22546, vinfo);
        ctx->errors = D.22547;
      }
      <D.22544>:
      ctx->valid = 0;
      return;
      <D.22541>:
      D.22538 = data[0];
      cconv = D.22538 & 1792;
      if (cconv == 0) goto <D.22548>; else goto <D.22550>;
      <D.22550>:
      if (cconv == 1536) goto <D.22548>; else goto <D.22551>;
      <D.22551>:
      if (cconv == 1792) goto <D.22548>; else goto <D.22549>;
      <D.22548>:
      D.22542 = ctx->report_error;
      if (D.22542 != 0) goto <D.22552>; else goto <D.22553>;
      <D.22552>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22554 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Invalid call conv field %x", i, cconv);
        vinfo->info.message = D.22554;
        vinfo->exception_type = 3;
        D.22546 = ctx->errors;
        D.22555 = monoeg_g_slist_prepend (D.22546, vinfo);
        ctx->errors = D.22555;
      }
      <D.22553>:
      ctx->valid = 0;
      return;
      <D.22549>:
      D.22556 = data[1];
      D.22557 = is_valid_coded_index (ctx, 56, D.22556);
      if (D.22557 == 0) goto <D.22558>; else goto <D.22559>;
      <D.22558>:
      D.22542 = ctx->report_error;
      if (D.22542 != 0) goto <D.22560>; else goto <D.22561>;
      <D.22560>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22556 = data[1];
        D.22562 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Invalid MemberForward token %x", i, D.22556);
        vinfo->info.message = D.22562;
        vinfo->exception_type = 3;
        D.22546 = ctx->errors;
        D.22563 = monoeg_g_slist_prepend (D.22546, vinfo);
        ctx->errors = D.22563;
      }
      <D.22561>:
      ctx->valid = 0;
      return;
      <D.22559>:
      D.22556 = data[1];
      D.22564 = get_coded_index_table (56, D.22556);
      if (D.22564 != 6) goto <D.22565>; else goto <D.22566>;
      <D.22565>:
      D.22542 = ctx->report_error;
      if (D.22542 != 0) goto <D.22567>; else goto <D.22568>;
      <D.22567>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22556 = data[1];
        D.22569 = monoeg_g_strdup_printf ("Invalid ImplMap row %d only methods are supported token %x", i, D.22556);
        vinfo->info.message = D.22569;
        vinfo->exception_type = 3;
        D.22546 = ctx->errors;
        D.22570 = monoeg_g_slist_prepend (D.22546, vinfo);
        ctx->errors = D.22570;
      }
      <D.22568>:
      ctx->valid = 0;
      return;
      <D.22566>:
      D.22556 = data[1];
      D.22571 = get_coded_index_token (56, D.22556);
      if (D.22571 == 0) goto <D.22572>; else goto <D.22573>;
      <D.22572>:
      D.22542 = ctx->report_error;
      if (D.22542 != 0) goto <D.22574>; else goto <D.22575>;
      <D.22574>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22576 = monoeg_g_strdup_printf ("Invalid ImplMap row %d null token", i);
        vinfo->info.message = D.22576;
        vinfo->exception_type = 3;
        D.22546 = ctx->errors;
        D.22577 = monoeg_g_slist_prepend (D.22546, vinfo);
        ctx->errors = D.22577;
      }
      <D.22575>:
      ctx->valid = 0;
      return;
      <D.22573>:
      D.22578 = data[2];
      D.22579 = is_valid_non_empty_string (ctx, D.22578);
      if (D.22579 == 0) goto <D.22580>; else goto <D.22581>;
      <D.22580>:
      D.22542 = ctx->report_error;
      if (D.22542 != 0) goto <D.22582>; else goto <D.22583>;
      <D.22582>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22578 = data[2];
        D.22584 = monoeg_g_strdup_printf ("Invalid ImplMap row %d ImportName Token %x", i, D.22578);
        vinfo->info.message = D.22584;
        vinfo->exception_type = 3;
        D.22546 = ctx->errors;
        D.22585 = monoeg_g_slist_prepend (D.22546, vinfo);
        ctx->errors = D.22585;
      }
      <D.22583>:
      ctx->valid = 0;
      return;
      <D.22581>:
      D.22588 = data[3];
      if (D.22588 == 0) goto <D.22586>; else goto <D.22589>;
      <D.22589>:
      D.22588 = data[3];
      D.22537 = ctx->image;
      D.22590 = D.22537->tables[26].rows;
      D.22591 = (unsigned int) D.22590;
      if (D.22588 > D.22591) goto <D.22586>; else goto <D.22587>;
      <D.22586>:
      D.22542 = ctx->report_error;
      if (D.22542 != 0) goto <D.22592>; else goto <D.22593>;
      <D.22592>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22588 = data[3];
        D.22594 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Invalid ImportScope token %x", i, D.22588);
        vinfo->info.message = D.22594;
        vinfo->exception_type = 3;
        D.22546 = ctx->errors;
        D.22595 = monoeg_g_slist_prepend (D.22546, vinfo);
        ctx->errors = D.22595;
      }
      <D.22593>:
      ctx->valid = 0;
      return;
      <D.22587>:
      i = i + 1;
      <D.18855>:
      D.22596 = table->rows;
      D.22597 = (int) D.22596;
      if (D.22597 > i) goto <D.18854>; else goto <D.18856>;
      <D.18856>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_fieldrva_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22601;
  unsigned int D.22604;
  unsigned int D.22606;
  int D.22607;
  gchar * D.22610;
  struct GSList * D.22611;
  struct GSList * D.22612;
  unsigned int D.22615;
  <unnamed-unsigned:24> D.22617;
  int D.22618;
  int D.22619;
  unsigned int D.22620;
  gchar * D.22623;
  struct GSList * D.22624;
  <unnamed-unsigned:24> D.22625;
  int D.22626;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.22601 = ctx->image;
      table = &D.22601->tables[29];
      i = 0;
      goto <D.18866>;
      <D.18865>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.22604 = data[0];
      if (D.22604 == 0) goto <D.22602>; else goto <D.22605>;
      <D.22605>:
      D.22601 = ctx->image;
      D.22604 = data[0];
      D.22606 = mono_cli_rva_image_map (D.22601, D.22604);
      if (D.22606 == 4294967295) goto <D.22602>; else goto <D.22603>;
      <D.22602>:
      D.22607 = ctx->report_error;
      if (D.22607 != 0) goto <D.22608>; else goto <D.22609>;
      <D.22608>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22604 = data[0];
        D.22610 = monoeg_g_strdup_printf ("Invalid FieldRVA row %d RVA %08x", i, D.22604);
        vinfo->info.message = D.22610;
        vinfo->exception_type = 3;
        D.22611 = ctx->errors;
        D.22612 = monoeg_g_slist_prepend (D.22611, vinfo);
        ctx->errors = D.22612;
      }
      <D.22609>:
      ctx->valid = 0;
      return;
      <D.22603>:
      D.22615 = data[1];
      if (D.22615 == 0) goto <D.22613>; else goto <D.22616>;
      <D.22616>:
      D.22615 = data[1];
      D.22601 = ctx->image;
      D.22617 = D.22601->tables[4].rows;
      D.22618 = (int) D.22617;
      D.22619 = D.22618 + 1;
      D.22620 = (unsigned int) D.22619;
      if (D.22615 > D.22620) goto <D.22613>; else goto <D.22614>;
      <D.22613>:
      D.22607 = ctx->report_error;
      if (D.22607 != 0) goto <D.22621>; else goto <D.22622>;
      <D.22621>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22615 = data[1];
        D.22623 = monoeg_g_strdup_printf ("Invalid FieldRVA row %d Field %08x", i, D.22615);
        vinfo->info.message = D.22623;
        vinfo->exception_type = 3;
        D.22611 = ctx->errors;
        D.22624 = monoeg_g_slist_prepend (D.22611, vinfo);
        ctx->errors = D.22624;
      }
      <D.22622>:
      ctx->valid = 0;
      return;
      <D.22614>:
      i = i + 1;
      <D.18866>:
      D.22625 = table->rows;
      D.22626 = (int) D.22625;
      if (D.22626 > i) goto <D.18865>; else goto <D.18867>;
      <D.18867>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_assembly_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22630;
  <unnamed-unsigned:24> D.22631;
  int D.22632;
  int D.22635;
  gchar * D.22638;
  struct GSList * D.22639;
  struct GSList * D.22640;
  gchar * D.22649;
  struct GSList * D.22650;
  unsigned int D.22651;
  unsigned int D.22652;
  gchar * D.22657;
  struct GSList * D.22658;
  unsigned int D.22659;
  int D.22662;
  gchar * D.22667;
  struct GSList * D.22668;
  unsigned int D.22669;
  int D.22670;
  gchar * D.22675;
  struct GSList * D.22676;
  unsigned int D.22677;
  int D.22680;
  gchar * D.22685;
  struct GSList * D.22686;
  struct MonoTableInfo * table;
  guint32 data[9];
  guint32 hash;
  int i;

  try
    {
      D.22630 = ctx->image;
      table = &D.22630->tables[32];
      D.22631 = table->rows;
      D.22632 = (int) D.22631;
      if (D.22632 > 1) goto <D.22633>; else goto <D.22634>;
      <D.22633>:
      D.22635 = ctx->report_error;
      if (D.22635 != 0) goto <D.22636>; else goto <D.22637>;
      <D.22636>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22631 = table->rows;
        D.22632 = (int) D.22631;
        D.22638 = monoeg_g_strdup_printf ("Assembly table can have zero or one rows, but now %d", D.22632);
        vinfo->info.message = D.22638;
        vinfo->exception_type = 3;
        D.22639 = ctx->errors;
        D.22640 = monoeg_g_slist_prepend (D.22639, vinfo);
        ctx->errors = D.22640;
      }
      <D.22637>:
      ctx->valid = 0;
      return;
      <D.22634>:
      i = 0;
      goto <D.18882>;
      <D.18881>:
      mono_metadata_decode_row (table, i, &data, 9);
      hash = data[0];
      if (hash != 0) goto <D.22641>; else goto <D.22642>;
      <D.22641>:
      if (hash != 32771) goto <D.22643>; else goto <D.22644>;
      <D.22643>:
      if (hash != 32772) goto <D.22645>; else goto <D.22646>;
      <D.22645>:
      D.22635 = ctx->report_error;
      if (D.22635 != 0) goto <D.22647>; else goto <D.22648>;
      <D.22647>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22649 = monoeg_g_strdup_printf ("Assembly table row %d has invalid HashAlgId %x", i, hash);
        vinfo->info.message = D.22649;
        vinfo->exception_type = 3;
        D.22639 = ctx->errors;
        D.22650 = monoeg_g_slist_prepend (D.22639, vinfo);
        ctx->errors = D.22650;
      }
      <D.22648>:
      ctx->valid = 0;
      return;
      <D.22646>:
      <D.22644>:
      <D.22642>:
      D.22651 = data[5];
      D.22652 = D.22651 & 4294917646;
      if (D.22652 != 0) goto <D.22653>; else goto <D.22654>;
      <D.22653>:
      D.22635 = ctx->report_error;
      if (D.22635 != 0) goto <D.22655>; else goto <D.22656>;
      <D.22655>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22651 = data[5];
        D.22657 = monoeg_g_strdup_printf ("Assembly table row %d has invalid Flags %08x", i, D.22651);
        vinfo->info.message = D.22657;
        vinfo->exception_type = 3;
        D.22639 = ctx->errors;
        D.22658 = monoeg_g_slist_prepend (D.22639, vinfo);
        ctx->errors = D.22658;
      }
      <D.22656>:
      ctx->valid = 0;
      return;
      <D.22654>:
      D.22659 = data[6];
      if (D.22659 != 0) goto <D.22660>; else goto <D.22661>;
      <D.22660>:
      D.22659 = data[6];
      D.22662 = is_valid_blob_object (ctx, D.22659, 1);
      if (D.22662 == 0) goto <D.22663>; else goto <D.22664>;
      <D.22663>:
      D.22635 = ctx->report_error;
      if (D.22635 != 0) goto <D.22665>; else goto <D.22666>;
      <D.22665>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22651 = data[5];
        D.22667 = monoeg_g_strdup_printf ("Assembly table row %d has invalid PublicKey %08x", i, D.22651);
        vinfo->info.message = D.22667;
        vinfo->exception_type = 3;
        D.22639 = ctx->errors;
        D.22668 = monoeg_g_slist_prepend (D.22639, vinfo);
        ctx->errors = D.22668;
      }
      <D.22666>:
      ctx->valid = 0;
      return;
      <D.22664>:
      <D.22661>:
      D.22669 = data[7];
      D.22670 = is_valid_non_empty_string (ctx, D.22669);
      if (D.22670 == 0) goto <D.22671>; else goto <D.22672>;
      <D.22671>:
      D.22635 = ctx->report_error;
      if (D.22635 != 0) goto <D.22673>; else goto <D.22674>;
      <D.22673>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22669 = data[7];
        D.22675 = monoeg_g_strdup_printf ("Assembly table row %d has invalid Name %08x", i, D.22669);
        vinfo->info.message = D.22675;
        vinfo->exception_type = 3;
        D.22639 = ctx->errors;
        D.22676 = monoeg_g_slist_prepend (D.22639, vinfo);
        ctx->errors = D.22676;
      }
      <D.22674>:
      ctx->valid = 0;
      return;
      <D.22672>:
      D.22677 = data[8];
      if (D.22677 != 0) goto <D.22678>; else goto <D.22679>;
      <D.22678>:
      D.22677 = data[8];
      D.22680 = is_valid_string (ctx, D.22677);
      if (D.22680 == 0) goto <D.22681>; else goto <D.22682>;
      <D.22681>:
      D.22635 = ctx->report_error;
      if (D.22635 != 0) goto <D.22683>; else goto <D.22684>;
      <D.22683>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22677 = data[8];
        D.22685 = monoeg_g_strdup_printf ("Assembly table row %d has invalid Culture %08x", i, D.22677);
        vinfo->info.message = D.22685;
        vinfo->exception_type = 3;
        D.22639 = ctx->errors;
        D.22686 = monoeg_g_slist_prepend (D.22639, vinfo);
        ctx->errors = D.22686;
      }
      <D.22684>:
      ctx->valid = 0;
      return;
      <D.22682>:
      <D.22679>:
      i = i + 1;
      <D.18882>:
      D.22631 = table->rows;
      D.22632 = (int) D.22631;
      if (D.22632 > i) goto <D.18881>; else goto <D.18883>;
      <D.18883>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_assemblyref_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22690;
  unsigned int D.22691;
  unsigned int D.22692;
  int D.22695;
  gchar * D.22698;
  struct GSList * D.22699;
  struct GSList * D.22700;
  unsigned int D.22701;
  int D.22704;
  gchar * D.22709;
  struct GSList * D.22710;
  unsigned int D.22711;
  int D.22712;
  gchar * D.22717;
  struct GSList * D.22718;
  unsigned int D.22719;
  int D.22722;
  gchar * D.22727;
  struct GSList * D.22728;
  unsigned int D.22729;
  int D.22732;
  gchar * D.22737;
  struct GSList * D.22738;
  <unnamed-unsigned:24> D.22739;
  int D.22740;
  struct MonoTableInfo * table;
  guint32 data[9];
  int i;

  try
    {
      D.22690 = ctx->image;
      table = &D.22690->tables[35];
      i = 0;
      goto <D.18896>;
      <D.18895>:
      mono_metadata_decode_row (table, i, &data, 9);
      D.22691 = data[4];
      D.22692 = D.22691 & 4294917886;
      if (D.22692 != 0) goto <D.22693>; else goto <D.22694>;
      <D.22693>:
      D.22695 = ctx->report_error;
      if (D.22695 != 0) goto <D.22696>; else goto <D.22697>;
      <D.22696>:
      {
        struct MonoVerifyInfoExtended * vinfo;

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

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22701 = data[5];
        D.22709 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid PublicKeyOrToken %08x", i, D.22701);
        vinfo->info.message = D.22709;
        vinfo->exception_type = 3;
        D.22699 = ctx->errors;
        D.22710 = monoeg_g_slist_prepend (D.22699, vinfo);
        ctx->errors = D.22710;
      }
      <D.22708>:
      ctx->valid = 0;
      return;
      <D.22706>:
      <D.22703>:
      D.22711 = data[6];
      D.22712 = is_valid_non_empty_string (ctx, D.22711);
      if (D.22712 == 0) goto <D.22713>; else goto <D.22714>;
      <D.22713>:
      D.22695 = ctx->report_error;
      if (D.22695 != 0) goto <D.22715>; else goto <D.22716>;
      <D.22715>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22711 = data[6];
        D.22717 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid Name %08x", i, D.22711);
        vinfo->info.message = D.22717;
        vinfo->exception_type = 3;
        D.22699 = ctx->errors;
        D.22718 = monoeg_g_slist_prepend (D.22699, vinfo);
        ctx->errors = D.22718;
      }
      <D.22716>:
      ctx->valid = 0;
      return;
      <D.22714>:
      D.22719 = data[7];
      if (D.22719 != 0) goto <D.22720>; else goto <D.22721>;
      <D.22720>:
      D.22719 = data[7];
      D.22722 = is_valid_string (ctx, D.22719);
      if (D.22722 == 0) goto <D.22723>; else goto <D.22724>;
      <D.22723>:
      D.22695 = ctx->report_error;
      if (D.22695 != 0) goto <D.22725>; else goto <D.22726>;
      <D.22725>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22719 = data[7];
        D.22727 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid Culture %08x", i, D.22719);
        vinfo->info.message = D.22727;
        vinfo->exception_type = 3;
        D.22699 = ctx->errors;
        D.22728 = monoeg_g_slist_prepend (D.22699, vinfo);
        ctx->errors = D.22728;
      }
      <D.22726>:
      ctx->valid = 0;
      return;
      <D.22724>:
      <D.22721>:
      D.22729 = data[8];
      if (D.22729 != 0) goto <D.22730>; else goto <D.22731>;
      <D.22730>:
      D.22729 = data[8];
      D.22732 = is_valid_blob_object (ctx, D.22729, 1);
      if (D.22732 == 0) goto <D.22733>; else goto <D.22734>;
      <D.22733>:
      D.22695 = ctx->report_error;
      if (D.22695 != 0) goto <D.22735>; else goto <D.22736>;
      <D.22735>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22729 = data[8];
        D.22737 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid HashValue %08x", i, D.22729);
        vinfo->info.message = D.22737;
        vinfo->exception_type = 3;
        D.22699 = ctx->errors;
        D.22738 = monoeg_g_slist_prepend (D.22699, vinfo);
        ctx->errors = D.22738;
      }
      <D.22736>:
      ctx->valid = 0;
      return;
      <D.22734>:
      <D.22731>:
      i = i + 1;
      <D.18896>:
      D.22739 = table->rows;
      D.22740 = (int) D.22739;
      if (D.22740 > i) goto <D.18895>; else goto <D.18897>;
      <D.18897>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_file_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22744;
  unsigned int D.22745;
  unsigned int D.22746;
  int D.22749;
  gchar * D.22752;
  struct GSList * D.22753;
  struct GSList * D.22754;
  unsigned int D.22755;
  int D.22756;
  gchar * D.22761;
  struct GSList * D.22762;
  unsigned int D.22765;
  int D.22767;
  gchar * D.22770;
  struct GSList * D.22771;
  <unnamed-unsigned:24> D.22772;
  int D.22773;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.22744 = ctx->image;
      table = &D.22744->tables[38];
      i = 0;
      goto <D.18908>;
      <D.18907>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.22745 = data[0];
      D.22746 = D.22745 & 4294967294;
      if (D.22746 != 0) goto <D.22747>; else goto <D.22748>;
      <D.22747>:
      D.22749 = ctx->report_error;
      if (D.22749 != 0) goto <D.22750>; else goto <D.22751>;
      <D.22750>:
      {
        struct MonoVerifyInfoExtended * vinfo;

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

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

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22765 = data[2];
        D.22770 = monoeg_g_strdup_printf ("File table row %d has invalid HashValue %08x", i, D.22765);
        vinfo->info.message = D.22770;
        vinfo->exception_type = 3;
        D.22753 = ctx->errors;
        D.22771 = monoeg_g_slist_prepend (D.22753, vinfo);
        ctx->errors = D.22771;
      }
      <D.22769>:
      ctx->valid = 0;
      return;
      <D.22764>:
      i = i + 1;
      <D.18908>:
      D.22772 = table->rows;
      D.22773 = (int) D.22772;
      if (D.22773 > i) goto <D.18907>; else goto <D.18909>;
      <D.18909>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_exportedtype_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22777;
  unsigned int D.22778;
  unsigned int D.22779;
  int D.22782;
  gchar * D.22785;
  struct GSList * D.22786;
  struct GSList * D.22787;
  unsigned int D.22788;
  int D.22789;
  unsigned int D.22794;
  gchar * D.22795;
  struct GSList * D.22796;
  unsigned int D.22797;
  int D.22800;
  gchar * D.22805;
  struct GSList * D.22806;
  unsigned int D.22807;
  int D.22808;
  gchar * D.22813;
  struct GSList * D.22814;
  unsigned int D.22815;
  gchar * D.22820;
  struct GSList * D.22821;
  unsigned int D.22822;
  gchar * D.22829;
  struct GSList * D.22830;
  <unnamed-unsigned:24> D.22831;
  int D.22832;
  struct MonoTableInfo * table;
  guint32 data[5];
  int i;

  try
    {
      D.22777 = ctx->image;
      table = &D.22777->tables[39];
      i = 0;
      goto <D.18923>;
      <D.18922>:
      mono_metadata_decode_row (table, i, &data, 5);
      D.22778 = data[0];
      D.22779 = D.22778 & 4278764096;
      if (D.22779 != 0) goto <D.22780>; else goto <D.22781>;
      <D.22780>:
      D.22782 = ctx->report_error;
      if (D.22782 != 0) goto <D.22783>; else goto <D.22784>;
      <D.22783>:
      {
        struct MonoVerifyInfoExtended * vinfo;

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

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22794 = data[1];
        D.22795 = monoeg_g_strdup_printf ("ExportedType table row %d has invalid TypeName %08x", i, D.22794);
        vinfo->info.message = D.22795;
        vinfo->exception_type = 3;
        D.22786 = ctx->errors;
        D.22796 = monoeg_g_slist_prepend (D.22786, vinfo);
        ctx->errors = D.22796;
      }
      <D.22793>:
      ctx->valid = 0;
      return;
      <D.22791>:
      D.22797 = data[3];
      if (D.22797 != 0) goto <D.22798>; else goto <D.22799>;
      <D.22798>:
      D.22797 = data[3];
      D.22800 = is_valid_string (ctx, D.22797);
      if (D.22800 == 0) goto <D.22801>; else goto <D.22802>;
      <D.22801>:
      D.22782 = ctx->report_error;
      if (D.22782 != 0) goto <D.22803>; else goto <D.22804>;
      <D.22803>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22797 = data[3];
        D.22805 = monoeg_g_strdup_printf ("ExportedType table row %d has invalid TypeNamespace %08x", i, D.22797);
        vinfo->info.message = D.22805;
        vinfo->exception_type = 3;
        D.22786 = ctx->errors;
        D.22806 = monoeg_g_slist_prepend (D.22786, vinfo);
        ctx->errors = D.22806;
      }
      <D.22804>:
      ctx->valid = 0;
      return;
      <D.22802>:
      <D.22799>:
      D.22807 = data[4];
      D.22808 = is_valid_coded_index (ctx, 60, D.22807);
      if (D.22808 == 0) goto <D.22809>; else goto <D.22810>;
      <D.22809>:
      D.22782 = ctx->report_error;
      if (D.22782 != 0) goto <D.22811>; else goto <D.22812>;
      <D.22811>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22807 = data[4];
        D.22813 = monoeg_g_strdup_printf ("ExportedType table row %d has invalid Implementation token %08x", i, D.22807);
        vinfo->info.message = D.22813;
        vinfo->exception_type = 3;
        D.22786 = ctx->errors;
        D.22814 = monoeg_g_slist_prepend (D.22786, vinfo);
        ctx->errors = D.22814;
      }
      <D.22812>:
      ctx->valid = 0;
      return;
      <D.22810>:
      D.22807 = data[4];
      D.22815 = get_coded_index_token (60, D.22807);
      if (D.22815 == 0) goto <D.22816>; else goto <D.22817>;
      <D.22816>:
      D.22782 = ctx->report_error;
      if (D.22782 != 0) goto <D.22818>; else goto <D.22819>;
      <D.22818>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22820 = monoeg_g_strdup_printf ("ExportedType table row %d has null Implementation token", i);
        vinfo->info.message = D.22820;
        vinfo->exception_type = 3;
        D.22786 = ctx->errors;
        D.22821 = monoeg_g_slist_prepend (D.22786, vinfo);
        ctx->errors = D.22821;
      }
      <D.22819>:
      ctx->valid = 0;
      return;
      <D.22817>:
      D.22807 = data[4];
      D.22822 = get_coded_index_table (60, D.22807);
      if (D.22822 == 39) goto <D.22823>; else goto <D.22824>;
      <D.22823>:
      D.22797 = data[3];
      if (D.22797 != 0) goto <D.22825>; else goto <D.22826>;
      <D.22825>:
      D.22782 = ctx->report_error;
      if (D.22782 != 0) goto <D.22827>; else goto <D.22828>;
      <D.22827>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22829 = monoeg_g_strdup_printf ("ExportedType table row %d has denotes a nested type but has a non null TypeNamespace", i);
        vinfo->info.message = D.22829;
        vinfo->exception_type = 3;
        D.22786 = ctx->errors;
        D.22830 = monoeg_g_slist_prepend (D.22786, vinfo);
        ctx->errors = D.22830;
      }
      <D.22828>:
      ctx->valid = 0;
      return;
      <D.22826>:
      <D.22824>:
      i = i + 1;
      <D.18923>:
      D.22831 = table->rows;
      D.22832 = (int) D.22831;
      if (D.22832 > i) goto <D.18922>; else goto <D.18924>;
      <D.18924>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_manifest_resource_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22836;
  unsigned int D.22837;
  unsigned int D.22838;
  int D.22841;
  gchar * D.22844;
  struct GSList * D.22845;
  struct GSList * D.22846;
  unsigned int D.22847;
  gchar * D.22852;
  struct GSList * D.22853;
  unsigned int D.22854;
  int D.22855;
  gchar * D.22860;
  struct GSList * D.22861;
  unsigned int D.22862;
  int D.22863;
  gchar * D.22868;
  struct GSList * D.22869;
  unsigned int D.22874;
  gchar * D.22875;
  struct GSList * D.22876;
  unsigned int D.22881;
  gchar * D.22886;
  struct GSList * D.22887;
  gchar * D.22894;
  struct GSList * D.22895;
  <unnamed-unsigned:24> D.22896;
  int D.22897;
  struct MonoCLIImageInfo * iinfo;
  struct MonoCLIHeader * ch;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 impl_table;
  guint32 token;
  guint32 resources_size;
  int i;

  try
    {
      D.22836 = ctx->image;
      iinfo = D.22836->image_info;
      ch = &iinfo->cli_cli_header;
      D.22836 = ctx->image;
      table = &D.22836->tables[40];
      resources_size = ch->ch_resources.size;
      i = 0;
      goto <D.18944>;
      <D.18943>:
      mono_metadata_decode_row (table, i, &data, 4);
      D.22837 = data[1];
      D.22838 = D.22837 & 4294967288;
      if (D.22838 != 0) goto <D.22839>; else goto <D.22840>;
      <D.22839>:
      D.22841 = ctx->report_error;
      if (D.22841 != 0) goto <D.22842>; else goto <D.22843>;
      <D.22842>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22837 = data[1];
        D.22844 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Flags %08x", i, D.22837);
        vinfo->info.message = D.22844;
        vinfo->exception_type = 3;
        D.22845 = ctx->errors;
        D.22846 = monoeg_g_slist_prepend (D.22845, vinfo);
        ctx->errors = D.22846;
      }
      <D.22843>:
      ctx->valid = 0;
      return;
      <D.22840>:
      D.22837 = data[1];
      D.22847 = D.22837 + 4294967295;
      if (D.22847 > 1) goto <D.22848>; else goto <D.22849>;
      <D.22848>:
      D.22841 = ctx->report_error;
      if (D.22841 != 0) goto <D.22850>; else goto <D.22851>;
      <D.22850>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22837 = data[1];
        D.22852 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Flags VisibilityMask %08x", i, D.22837);
        vinfo->info.message = D.22852;
        vinfo->exception_type = 3;
        D.22845 = ctx->errors;
        D.22853 = monoeg_g_slist_prepend (D.22845, vinfo);
        ctx->errors = D.22853;
      }
      <D.22851>:
      ctx->valid = 0;
      return;
      <D.22849>:
      D.22854 = data[2];
      D.22855 = is_valid_non_empty_string (ctx, D.22854);
      if (D.22855 == 0) goto <D.22856>; else goto <D.22857>;
      <D.22856>:
      D.22841 = ctx->report_error;
      if (D.22841 != 0) goto <D.22858>; else goto <D.22859>;
      <D.22858>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22854 = data[2];
        D.22860 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Name %08x", i, D.22854);
        vinfo->info.message = D.22860;
        vinfo->exception_type = 3;
        D.22845 = ctx->errors;
        D.22861 = monoeg_g_slist_prepend (D.22845, vinfo);
        ctx->errors = D.22861;
      }
      <D.22859>:
      ctx->valid = 0;
      return;
      <D.22857>:
      D.22862 = data[3];
      D.22863 = is_valid_coded_index (ctx, 60, D.22862);
      if (D.22863 == 0) goto <D.22864>; else goto <D.22865>;
      <D.22864>:
      D.22841 = ctx->report_error;
      if (D.22841 != 0) goto <D.22866>; else goto <D.22867>;
      <D.22866>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22862 = data[3];
        D.22868 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Implementation token %08x", i, D.22862);
        vinfo->info.message = D.22868;
        vinfo->exception_type = 3;
        D.22845 = ctx->errors;
        D.22869 = monoeg_g_slist_prepend (D.22845, vinfo);
        ctx->errors = D.22869;
      }
      <D.22867>:
      ctx->valid = 0;
      return;
      <D.22865>:
      D.22862 = data[3];
      impl_table = get_coded_index_table (60, D.22862);
      D.22862 = data[3];
      token = get_coded_index_token (60, D.22862);
      if (impl_table == 39) goto <D.22870>; else goto <D.22871>;
      <D.22870>:
      D.22841 = ctx->report_error;
      if (D.22841 != 0) goto <D.22872>; else goto <D.22873>;
      <D.22872>:
      {
        struct MonoVerifyInfoExtended * vinfo;

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

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22886 = monoeg_g_strdup_printf ("ManifestResource table row %d points to a file but has non-zero offset", i);
        vinfo->info.message = D.22886;
        vinfo->exception_type = 3;
        D.22845 = ctx->errors;
        D.22887 = monoeg_g_slist_prepend (D.22845, vinfo);
        ctx->errors = D.22887;
      }
      <D.22885>:
      ctx->valid = 0;
      return;
      <D.22883>:
      <D.22880>:
      <D.22878>:
      if (token == 0) goto <D.22888>; else goto <D.22889>;
      <D.22888>:
      D.22881 = data[0];
      if (D.22881 >= resources_size) goto <D.22890>; else goto <D.22891>;
      <D.22890>:
      D.22841 = ctx->report_error;
      if (D.22841 != 0) goto <D.22892>; else goto <D.22893>;
      <D.22892>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22881 = data[0];
        D.22894 = monoeg_g_strdup_printf ("ManifestResource table row %d invalid Offset field %08x ", i, D.22881);
        vinfo->info.message = D.22894;
        vinfo->exception_type = 3;
        D.22845 = ctx->errors;
        D.22895 = monoeg_g_slist_prepend (D.22845, vinfo);
        ctx->errors = D.22895;
      }
      <D.22893>:
      ctx->valid = 0;
      return;
      <D.22891>:
      <D.22889>:
      i = i + 1;
      <D.18944>:
      D.22896 = table->rows;
      D.22897 = (int) D.22896;
      if (D.22897 > i) goto <D.18943>; else goto <D.18945>;
      <D.18945>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_nested_class_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22901;
  unsigned int D.22904;
  <unnamed-unsigned:24> D.22906;
  unsigned int D.22907;
  int D.22908;
  gchar * D.22911;
  struct GSList * D.22912;
  struct GSList * D.22913;
  unsigned int D.22916;
  gchar * D.22920;
  struct GSList * D.22921;
  gchar * D.22926;
  struct GSList * D.22927;
  <unnamed-unsigned:24> D.22928;
  int D.22929;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.22901 = ctx->image;
      table = &D.22901->tables[41];
      i = 0;
      goto <D.18956>;
      <D.18955>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.22904 = data[0];
      if (D.22904 == 0) goto <D.22902>; else goto <D.22905>;
      <D.22905>:
      D.22904 = data[0];
      D.22901 = ctx->image;
      D.22906 = D.22901->tables[2].rows;
      D.22907 = (unsigned int) D.22906;
      if (D.22904 > D.22907) goto <D.22902>; else goto <D.22903>;
      <D.22902>:
      D.22908 = ctx->report_error;
      if (D.22908 != 0) goto <D.22909>; else goto <D.22910>;
      <D.22909>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22904 = data[0];
        D.22911 = monoeg_g_strdup_printf ("NestedClass table row %d has invalid NestedClass token %08x", i, D.22904);
        vinfo->info.message = D.22911;
        vinfo->exception_type = 3;
        D.22912 = ctx->errors;
        D.22913 = monoeg_g_slist_prepend (D.22912, vinfo);
        ctx->errors = D.22913;
      }
      <D.22910>:
      ctx->valid = 0;
      return;
      <D.22903>:
      D.22916 = data[1];
      if (D.22916 == 0) goto <D.22914>; else goto <D.22917>;
      <D.22917>:
      D.22916 = data[1];
      D.22901 = ctx->image;
      D.22906 = D.22901->tables[2].rows;
      D.22907 = (unsigned int) D.22906;
      if (D.22916 > D.22907) goto <D.22914>; else goto <D.22915>;
      <D.22914>:
      D.22908 = ctx->report_error;
      if (D.22908 != 0) goto <D.22918>; else goto <D.22919>;
      <D.22918>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22916 = data[1];
        D.22920 = monoeg_g_strdup_printf ("NestedClass table row %d has invalid EnclosingClass token %08x", i, D.22916);
        vinfo->info.message = D.22920;
        vinfo->exception_type = 3;
        D.22912 = ctx->errors;
        D.22921 = monoeg_g_slist_prepend (D.22912, vinfo);
        ctx->errors = D.22921;
      }
      <D.22919>:
      ctx->valid = 0;
      return;
      <D.22915>:
      D.22916 = data[1];
      D.22904 = data[0];
      if (D.22916 == D.22904) goto <D.22922>; else goto <D.22923>;
      <D.22922>:
      D.22908 = ctx->report_error;
      if (D.22908 != 0) goto <D.22924>; else goto <D.22925>;
      <D.22924>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22916 = data[1];
        D.22926 = monoeg_g_strdup_printf ("NestedClass table row %d has same token for NestedClass  and EnclosingClass %08x", i, D.22916);
        vinfo->info.message = D.22926;
        vinfo->exception_type = 3;
        D.22912 = ctx->errors;
        D.22927 = monoeg_g_slist_prepend (D.22912, vinfo);
        ctx->errors = D.22927;
      }
      <D.22925>:
      ctx->valid = 0;
      return;
      <D.22923>:
      i = i + 1;
      <D.18956>:
      D.22928 = table->rows;
      D.22929 = (int) D.22928;
      if (D.22929 > i) goto <D.18955>; else goto <D.18957>;
      <D.18957>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_generic_param_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22933;
  unsigned int D.22934;
  unsigned int D.22935;
  int D.22938;
  gchar * D.22941;
  struct GSList * D.22942;
  struct GSList * D.22943;
  unsigned int D.22944;
  gchar * D.22949;
  struct GSList * D.22950;
  unsigned int D.22951;
  int D.22952;
  gchar * D.22957;
  struct GSList * D.22958;
  int D.22959;
  gchar * D.22964;
  struct GSList * D.22965;
  unsigned int D.22966;
  gchar * D.22971;
  struct GSList * D.22972;
  unsigned int D.22975;
  unsigned int param_number.98;
  gchar * D.22981;
  struct GSList * D.22982;
  <unnamed-unsigned:24> D.22983;
  int D.22984;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 token;
  guint32 last_token;
  int i;
  int param_number;

  try
    {
      D.22933 = ctx->image;
      table = &D.22933->tables[42];
      last_token = 0;
      param_number = 0;
      i = 0;
      goto <D.18974>;
      <D.18973>:
      mono_metadata_decode_row (table, i, &data, 4);
      D.22934 = data[1];
      D.22935 = D.22934 & 4294967264;
      if (D.22935 != 0) goto <D.22936>; else goto <D.22937>;
      <D.22936>:
      D.22938 = ctx->report_error;
      if (D.22938 != 0) goto <D.22939>; else goto <D.22940>;
      <D.22939>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22934 = data[1];
        D.22941 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid Flags token %08x", i, D.22934);
        vinfo->info.message = D.22941;
        vinfo->exception_type = 3;
        D.22942 = ctx->errors;
        D.22943 = monoeg_g_slist_prepend (D.22942, vinfo);
        ctx->errors = D.22943;
      }
      <D.22940>:
      ctx->valid = 0;
      return;
      <D.22937>:
      D.22934 = data[1];
      D.22944 = D.22934 & 3;
      if (D.22944 == 3) goto <D.22945>; else goto <D.22946>;
      <D.22945>:
      D.22938 = ctx->report_error;
      if (D.22938 != 0) goto <D.22947>; else goto <D.22948>;
      <D.22947>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22949 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid VarianceMask 0x3", i);
        vinfo->info.message = D.22949;
        vinfo->exception_type = 3;
        D.22942 = ctx->errors;
        D.22950 = monoeg_g_slist_prepend (D.22942, vinfo);
        ctx->errors = D.22950;
      }
      <D.22948>:
      ctx->valid = 0;
      return;
      <D.22946>:
      D.22951 = data[3];
      D.22952 = is_valid_non_empty_string (ctx, D.22951);
      if (D.22952 == 0) goto <D.22953>; else goto <D.22954>;
      <D.22953>:
      D.22938 = ctx->report_error;
      if (D.22938 != 0) goto <D.22955>; else goto <D.22956>;
      <D.22955>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22951 = data[3];
        D.22957 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid Name token %08x", i, D.22951);
        vinfo->info.message = D.22957;
        vinfo->exception_type = 3;
        D.22942 = ctx->errors;
        D.22958 = monoeg_g_slist_prepend (D.22942, vinfo);
        ctx->errors = D.22958;
      }
      <D.22956>:
      ctx->valid = 0;
      return;
      <D.22954>:
      token = data[2];
      D.22959 = is_valid_coded_index (ctx, 78, token);
      if (D.22959 == 0) goto <D.22960>; else goto <D.22961>;
      <D.22960>:
      D.22938 = ctx->report_error;
      if (D.22938 != 0) goto <D.22962>; else goto <D.22963>;
      <D.22962>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22964 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid Owner token %08x", i, token);
        vinfo->info.message = D.22964;
        vinfo->exception_type = 3;
        D.22942 = ctx->errors;
        D.22965 = monoeg_g_slist_prepend (D.22942, vinfo);
        ctx->errors = D.22965;
      }
      <D.22963>:
      ctx->valid = 0;
      return;
      <D.22961>:
      D.22966 = get_coded_index_token (78, token);
      if (D.22966 == 0) goto <D.22967>; else goto <D.22968>;
      <D.22967>:
      D.22938 = ctx->report_error;
      if (D.22938 != 0) goto <D.22969>; else goto <D.22970>;
      <D.22969>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22971 = monoeg_g_strdup_printf ("GenericParam table row %d has null Owner token", i);
        vinfo->info.message = D.22971;
        vinfo->exception_type = 3;
        D.22942 = ctx->errors;
        D.22972 = monoeg_g_slist_prepend (D.22942, vinfo);
        ctx->errors = D.22972;
      }
      <D.22970>:
      ctx->valid = 0;
      return;
      <D.22968>:
      if (token != last_token) goto <D.22973>; else goto <D.22974>;
      <D.22973>:
      param_number = 0;
      last_token = token;
      <D.22974>:
      D.22975 = data[0];
      param_number.98 = (unsigned int) param_number;
      if (D.22975 != param_number.98) goto <D.22977>; else goto <D.22978>;
      <D.22977>:
      D.22938 = ctx->report_error;
      if (D.22938 != 0) goto <D.22979>; else goto <D.22980>;
      <D.22979>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22975 = data[0];
        D.22981 = monoeg_g_strdup_printf ("GenericParam table row %d Number is out of order %d expected %d", i, D.22975, param_number);
        vinfo->info.message = D.22981;
        vinfo->exception_type = 3;
        D.22942 = ctx->errors;
        D.22982 = monoeg_g_slist_prepend (D.22942, vinfo);
        ctx->errors = D.22982;
      }
      <D.22980>:
      ctx->valid = 0;
      return;
      <D.22978>:
      param_number = param_number + 1;
      i = i + 1;
      <D.18974>:
      D.22983 = table->rows;
      D.22984 = (int) D.22983;
      if (D.22984 > i) goto <D.18973>; else goto <D.18975>;
      <D.18975>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_method_spec_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22988;
  unsigned int D.22989;
  int D.22990;
  int D.22993;
  gchar * D.22996;
  struct GSList * D.22997;
  struct GSList * D.22998;
  unsigned int D.22999;
  gchar * D.23004;
  struct GSList * D.23005;
  unsigned int D.23006;
  int D.23009;
  gchar * D.23014;
  struct GSList * D.23015;
  <unnamed-unsigned:24> D.23016;
  int D.23017;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.22988 = ctx->image;
      table = &D.22988->tables[43];
      i = 0;
      goto <D.18986>;
      <D.18985>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.22989 = data[0];
      D.22990 = is_valid_coded_index (ctx, 52, D.22989);
      if (D.22990 == 0) goto <D.22991>; else goto <D.22992>;
      <D.22991>:
      D.22993 = ctx->report_error;
      if (D.22993 != 0) goto <D.22994>; else goto <D.22995>;
      <D.22994>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22989 = data[0];
        D.22996 = monoeg_g_strdup_printf ("MethodSpec table row %d has invalid Method token %08x", i, D.22989);
        vinfo->info.message = D.22996;
        vinfo->exception_type = 3;
        D.22997 = ctx->errors;
        D.22998 = monoeg_g_slist_prepend (D.22997, vinfo);
        ctx->errors = D.22998;
      }
      <D.22995>:
      ctx->valid = 0;
      return;
      <D.22992>:
      D.22989 = data[0];
      D.22999 = get_coded_index_token (52, D.22989);
      if (D.22999 == 0) goto <D.23000>; else goto <D.23001>;
      <D.23000>:
      D.22993 = ctx->report_error;
      if (D.22993 != 0) goto <D.23002>; else goto <D.23003>;
      <D.23002>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23004 = monoeg_g_strdup_printf ("MethodSpec table row %d has null Method token", i);
        vinfo->info.message = D.23004;
        vinfo->exception_type = 3;
        D.22997 = ctx->errors;
        D.23005 = monoeg_g_slist_prepend (D.22997, vinfo);
        ctx->errors = D.23005;
      }
      <D.23003>:
      ctx->valid = 0;
      return;
      <D.23001>:
      D.23006 = data[1];
      if (D.23006 != 0) goto <D.23007>; else goto <D.23008>;
      <D.23007>:
      D.23006 = data[1];
      D.23009 = is_valid_blob_object (ctx, D.23006, 1);
      if (D.23009 == 0) goto <D.23010>; else goto <D.23011>;
      <D.23010>:
      D.22993 = ctx->report_error;
      if (D.22993 != 0) goto <D.23012>; else goto <D.23013>;
      <D.23012>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23006 = data[1];
        D.23014 = monoeg_g_strdup_printf ("MethodSpec table row %d has invalid signature token %08x", i, D.23006);
        vinfo->info.message = D.23014;
        vinfo->exception_type = 3;
        D.22997 = ctx->errors;
        D.23015 = monoeg_g_slist_prepend (D.22997, vinfo);
        ctx->errors = D.23015;
      }
      <D.23013>:
      ctx->valid = 0;
      return;
      <D.23011>:
      <D.23008>:
      i = i + 1;
      <D.18986>:
      D.23016 = table->rows;
      D.23017 = (int) D.23016;
      if (D.23017 > i) goto <D.18985>; else goto <D.18987>;
      <D.18987>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_generic_param_constraint_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23021;
  unsigned int D.23024;
  <unnamed-unsigned:24> D.23026;
  unsigned int D.23027;
  int D.23028;
  gchar * D.23031;
  struct GSList * D.23032;
  struct GSList * D.23033;
  unsigned int D.23034;
  int D.23035;
  gchar * D.23040;
  struct GSList * D.23041;
  unsigned int D.23042;
  gchar * D.23047;
  struct GSList * D.23048;
  gchar * D.23053;
  struct GSList * D.23054;
  gchar * D.23061;
  struct GSList * D.23062;
  <unnamed-unsigned:24> D.23064;
  int D.23065;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;
  guint32 last_owner;
  guint32 last_constraint;

  try
    {
      D.23021 = ctx->image;
      table = &D.23021->tables[44];
      last_owner = 0;
      last_constraint = 0;
      i = 0;
      goto <D.19012>;
      <D.19011>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.23024 = data[0];
      if (D.23024 == 0) goto <D.23022>; else goto <D.23025>;
      <D.23025>:
      D.23024 = data[0];
      D.23021 = ctx->image;
      D.23026 = D.23021->tables[42].rows;
      D.23027 = (unsigned int) D.23026;
      if (D.23024 > D.23027) goto <D.23022>; else goto <D.23023>;
      <D.23022>:
      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 ("GenericParamConstraint table row %d has invalid Owner 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.23023>:
      D.23034 = data[1];
      D.23035 = is_valid_coded_index (ctx, 0, D.23034);
      if (D.23035 == 0) goto <D.23036>; else goto <D.23037>;
      <D.23036>:
      D.23028 = ctx->report_error;
      if (D.23028 != 0) goto <D.23038>; else goto <D.23039>;
      <D.23038>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23034 = data[1];
        D.23040 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d has invalid Constraint token %08x", i, D.23034);
        vinfo->info.message = D.23040;
        vinfo->exception_type = 3;
        D.23032 = ctx->errors;
        D.23041 = monoeg_g_slist_prepend (D.23032, vinfo);
        ctx->errors = D.23041;
      }
      <D.23039>:
      ctx->valid = 0;
      return;
      <D.23037>:
      D.23034 = data[1];
      D.23042 = get_coded_index_token (0, D.23034);
      if (D.23042 == 0) goto <D.23043>; else goto <D.23044>;
      <D.23043>:
      D.23028 = ctx->report_error;
      if (D.23028 != 0) goto <D.23045>; else goto <D.23046>;
      <D.23045>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23047 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d has null Constraint token", i);
        vinfo->info.message = D.23047;
        vinfo->exception_type = 3;
        D.23032 = ctx->errors;
        D.23048 = monoeg_g_slist_prepend (D.23032, vinfo);
        ctx->errors = D.23048;
      }
      <D.23046>:
      ctx->valid = 0;
      return;
      <D.23044>:
      D.23024 = data[0];
      if (D.23024 < last_owner) goto <D.23049>; else goto <D.23050>;
      <D.23049>:
      D.23028 = ctx->report_error;
      if (D.23028 != 0) goto <D.23051>; else goto <D.23052>;
      <D.23051>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23024 = data[0];
        D.23053 = 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.23024);
        vinfo->info.message = D.23053;
        vinfo->exception_type = 3;
        D.23032 = ctx->errors;
        D.23054 = monoeg_g_slist_prepend (D.23032, vinfo);
        ctx->errors = D.23054;
      }
      <D.23052>:
      ctx->valid = 0;
      return;
      <D.23050>:
      D.23024 = data[0];
      if (D.23024 == last_owner) goto <D.23055>; else goto <D.23056>;
      <D.23055>:
      D.23034 = data[1];
      if (D.23034 == last_constraint) goto <D.23057>; else goto <D.23058>;
      <D.23057>:
      D.23028 = ctx->report_error;
      if (D.23028 != 0) goto <D.23059>; else goto <D.23060>;
      <D.23059>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23061 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d has duplicate constraint 0x%08x", i, last_constraint);
        vinfo->info.message = D.23061;
        vinfo->exception_type = 3;
        D.23032 = ctx->errors;
        D.23062 = monoeg_g_slist_prepend (D.23032, vinfo);
        ctx->errors = D.23062;
      }
      <D.23060>:
      ctx->valid = 0;
      return;
      <D.23058>:
      goto <D.23063>;
      <D.23056>:
      last_owner = data[0];
      <D.23063>:
      last_constraint = data[1];
      i = i + 1;
      <D.19012>:
      D.23064 = table->rows;
      D.23065 = (int) D.23064;
      if (D.23065 > i) goto <D.19011>; else goto <D.19013>;
      <D.19013>:
    }
  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.23069;
  unsigned int D.23070;
  const char * D.23071;
  unsigned int D.23072;
  const char * D.23073;
  unsigned int D.23074;
  unsigned int D.23075;
  int D.23078;
  unsigned int D.23079;
  _Bool D.23080;
  long int D.23081;
  long int D.23082;
  unsigned int D.23085;
  void * D.23086;
  int D.23089;
  const char * D.23092;
  const char * D.23093;
  unsigned int D.23094;
  gchar * D.23095;
  struct GSList * D.23096;
  struct GSList * D.23097;
  <unnamed-unsigned:24> D.23098;
  int D.23099;
  int i;
  guint32 data[6];
  guint32 nested_data[2];
  struct MonoTableInfo * table;
  struct MonoTableInfo * nested_table;
  struct GHashTable * unique_types;

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

        type = monoeg_malloc (12);
        mono_metadata_decode_row (table, i, &data, 6);
        D.23069 = ctx->image;
        D.23070 = data[1];
        D.23071 = mono_metadata_string_heap (D.23069, D.23070);
        type->name = D.23071;
        D.23069 = ctx->image;
        D.23072 = data[2];
        D.23073 = mono_metadata_string_heap (D.23069, D.23072);
        type->name_space = D.23073;
        type->resolution_scope = 0;
        D.23074 = data[0];
        visibility = D.23074 & 7;
        D.23075 = visibility + 4294967294;
        if (D.23075 <= 5) goto <D.23076>; else goto <D.23077>;
        <D.23076>:
        {
          int res;

          D.23078 = i + 1;
          D.23079 = (unsigned int) D.23078;
          res = search_sorted_table (ctx, 41, 0, D.23079);
          D.23080 = res < 0;
          D.23081 = (long int) D.23080;
          D.23082 = __builtin_expect (D.23081, 0);
          if (D.23082 != 0) goto <D.23083>; else goto <D.23084>;
          <D.23083>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 3700, "res >= 0");
          <D.23084>:
          mono_metadata_decode_row (nested_table, res, &nested_data, 2);
          D.23085 = nested_data[1];
          type->resolution_scope = D.23085;
        }
        <D.23077>:
        D.23086 = monoeg_g_hash_table_lookup (unique_types, type);
        if (D.23086 != 0B) goto <D.23087>; else goto <D.23088>;
        <D.23087>:
        D.23089 = ctx->report_error;
        if (D.23089 != 0) goto <D.23090>; else goto <D.23091>;
        <D.23090>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.23092 = type->name;
          D.23093 = type->name_space;
          D.23094 = type->resolution_scope;
          D.23095 = monoeg_g_strdup_printf ("TypeDef table row %d has duplicate for tuple (%s,%s,%x)", i, D.23092, D.23093, D.23094);
          vinfo->info.message = D.23095;
          vinfo->exception_type = 3;
          D.23096 = ctx->errors;
          D.23097 = monoeg_g_slist_prepend (D.23096, vinfo);
          ctx->errors = D.23097;
        }
        <D.23091>:
        ctx->valid = 0;
        monoeg_g_hash_table_destroy (unique_types);
        monoeg_g_free (type);
        return;
        <D.23088>:
        monoeg_g_hash_table_insert_replace (unique_types, type, 1B, 0);
      }
      i = i + 1;
      <D.19061>:
      D.23098 = table->rows;
      D.23099 = (int) D.23098;
      if (D.23099 > i) goto <D.19060>; else goto <D.19062>;
      <D.19062>:
      monoeg_g_hash_table_destroy (unique_types);
    }
  finally
    {
      data = {CLOBBER};
      nested_data = {CLOBBER};
    }
}


typedef_equals (const void * _a, const void * _b)
{
  gboolean D.23103;
  int iftmp.99;
  int D.19037;
  const char * D.23107;
  const char * D.23108;
  int D.19046;
  const char * D.23110;
  const char * D.23111;
  unsigned int D.23113;
  unsigned int D.23114;
  const struct TypeDefUniqueId * a;
  const struct TypeDefUniqueId * b;

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

    D.23107 = a->name;
    D.23108 = b->name;
    D.19037 = __builtin_strcmp (D.23107, D.23108);
  }
  if (D.19037 == 0) goto <D.23109>; else goto <D.23105>;
  <D.23109>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.23110 = a->name_space;
    D.23111 = b->name_space;
    D.19046 = __builtin_strcmp (D.23110, D.23111);
  }
  if (D.19046 == 0) goto <D.23112>; else goto <D.23105>;
  <D.23112>:
  D.23113 = a->resolution_scope;
  D.23114 = b->resolution_scope;
  if (D.23113 == D.23114) goto <D.23115>; else goto <D.23105>;
  <D.23115>:
  iftmp.99 = 1;
  goto <D.23106>;
  <D.23105>:
  iftmp.99 = 0;
  <D.23106>:
  D.23103 = iftmp.99;
  return D.23103;
}


typedef_hash (const void * _key)
{
  guint D.23117;
  const char * D.23118;
  unsigned int D.23119;
  const char * D.23120;
  unsigned int D.23121;
  unsigned int D.23122;
  unsigned int D.23123;
  const struct TypeDefUniqueId * key;

  key = _key;
  D.23118 = key->name;
  D.23119 = monoeg_g_str_hash (D.23118);
  D.23120 = key->name_space;
  D.23121 = monoeg_g_str_hash (D.23120);
  D.23122 = D.23119 ^ D.23121;
  D.23123 = key->resolution_scope;
  D.23117 = D.23122 ^ D.23123;
  return D.23117;
}


mono_verifier_verify_full_table_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.23125;
  gboolean D.23128;
  _Bool D.23129;
  int D.23130;
  int D.23131;
  struct VerifyContext ctx;
  void cleanup = <<< error >>>;

  try
    {
      D.23125 = mono_verifier_is_enabled_for_image (image);
      if (D.23125 == 0) goto <D.23126>; else goto <D.23127>;
      <D.23126>:
      D.23128 = 1;
      return D.23128;
      <D.23127>:
      D.23129 = error_list != 0B;
      D.23130 = (int) D.23129;
      init_verify_context (&ctx, image, D.23130);
      ctx.stage = 2;
      verify_typedef_table_full (&ctx);
      D.23131 = ctx.valid;
      if (D.23131 == 0) goto cleanup; else goto <D.23132>;
      <D.23132>:
      verify_field_table_full (&ctx);
      D.23131 = ctx.valid;
      if (D.23131 == 0) goto cleanup; else goto <D.23133>;
      <D.23133>:
      verify_method_table_full (&ctx);
      D.23131 = ctx.valid;
      if (D.23131 == 0) goto cleanup; else goto <D.23134>;
      <D.23134>:
      verify_memberref_table_full (&ctx);
      D.23131 = ctx.valid;
      if (D.23131 == 0) goto cleanup; else goto <D.23135>;
      <D.23135>:
      verify_cattr_table_full (&ctx);
      D.23131 = ctx.valid;
      if (D.23131 == 0) goto cleanup; else goto <D.23136>;
      <D.23136>:
      verify_field_marshal_table_full (&ctx);
      D.23131 = ctx.valid;
      if (D.23131 == 0) goto cleanup; else goto <D.23137>;
      <D.23137>:
      verify_decl_security_table_full (&ctx);
      D.23131 = ctx.valid;
      if (D.23131 == 0) goto cleanup; else goto <D.23138>;
      <D.23138>:
      verify_standalonesig_table_full (&ctx);
      D.23131 = ctx.valid;
      if (D.23131 == 0) goto cleanup; else goto <D.23139>;
      <D.23139>:
      verify_event_table_full (&ctx);
      D.23131 = ctx.valid;
      if (D.23131 == 0) goto cleanup; else goto <D.23140>;
      <D.23140>:
      verify_typespec_table_full (&ctx);
      D.23131 = ctx.valid;
      if (D.23131 == 0) goto cleanup; else goto <D.23141>;
      <D.23141>:
      verify_method_spec_table_full (&ctx);
      D.23131 = ctx.valid;
      if (D.23131 == 0) goto cleanup; else goto <D.23142>;
      <D.23142>:
      verify_tables_data_global_constraints_full (&ctx);
      cleanup:
      D.23128 = cleanup_context (&ctx, error_list);
      return D.23128;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


verify_typedef_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.23145;
  unsigned int D.23146;
  unsigned int D.23147;
  int D.23150;
  gchar * D.23153;
  struct GSList * D.23154;
  struct GSList * D.23155;
  unsigned int D.23158;
  unsigned int D.23159;
  unsigned int D.23162;
  gchar * D.23167;
  struct GSList * D.23168;
  unsigned int D.23170;
  _Bool D.23171;
  gchar * D.23178;
  struct GSList * D.23179;
  gchar * D.23185;
  struct GSList * D.23186;
  <unnamed-unsigned:24> D.23187;
  int D.23188;
  struct MonoTableInfo * table;
  guint32 data[6];
  int i;

  try
    {
      D.23145 = ctx->image;
      table = &D.23145->tables[2];
      D.23146 = BIT_FIELD_REF <*table, 32, 32>;
      D.23147 = D.23146 & 16777215;
      if (D.23147 == 0) goto <D.23148>; else goto <D.23149>;
      <D.23148>:
      D.23150 = ctx->report_error;
      if (D.23150 != 0) goto <D.23151>; else goto <D.23152>;
      <D.23151>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23153 = monoeg_g_strdup_printf ("Typedef table must have exactly at least one row");
        vinfo->info.message = D.23153;
        vinfo->exception_type = 3;
        D.23154 = ctx->errors;
        D.23155 = monoeg_g_slist_prepend (D.23154, vinfo);
        ctx->errors = D.23155;
      }
      <D.23152>:
      ctx->valid = 0;
      return;
      <D.23149>:
      i = 0;
      goto <D.18395>;
      <D.18394>:
      mono_metadata_decode_row (table, i, &data, 6);
      if (i == 0) goto <D.23156>; else goto <D.23157>;
      <D.23156>:
      // predicted unlikely by continue predictor.
      goto <D.18388>;
      <D.23157>:
      D.23158 = data[0];
      D.23159 = D.23158 & 32;
      if (D.23159 != 0) goto <D.23160>; else goto <D.23161>;
      <D.23160>:
      D.23162 = data[3];
      if (D.23162 != 0) goto <D.23163>; else goto <D.23164>;
      <D.23163>:
      D.23150 = ctx->report_error;
      if (D.23150 != 0) goto <D.23165>; else goto <D.23166>;
      <D.23165>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23167 = monoeg_g_strdup_printf ("Invalid typedef row %d for interface type must have a null extend field", i);
        vinfo->info.message = D.23167;
        vinfo->exception_type = 3;
        D.23154 = ctx->errors;
        D.23168 = monoeg_g_slist_prepend (D.23154, vinfo);
        ctx->errors = D.23168;
      }
      <D.23166>:
      ctx->valid = 0;
      return;
      <D.23164>:
      goto <D.23169>;
      <D.23161>:
      {
        gboolean is_sys_obj;
        gboolean has_parent;

        is_sys_obj = typedef_is_system_object (ctx, &data);
        D.23162 = data[3];
        D.23170 = get_coded_index_token (0, D.23162);
        D.23171 = D.23170 != 0;
        has_parent = (gboolean) D.23171;
        if (is_sys_obj != 0) goto <D.23172>; else goto <D.23173>;
        <D.23172>:
        if (has_parent != 0) goto <D.23174>; else goto <D.23175>;
        <D.23174>:
        D.23150 = ctx->report_error;
        if (D.23150 != 0) goto <D.23176>; else goto <D.23177>;
        <D.23176>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.23178 = monoeg_g_strdup_printf ("Invalid typedef row %d for System.Object must have a null extend field", i);
          vinfo->info.message = D.23178;
          vinfo->exception_type = 3;
          D.23154 = ctx->errors;
          D.23179 = monoeg_g_slist_prepend (D.23154, vinfo);
          ctx->errors = D.23179;
        }
        <D.23177>:
        ctx->valid = 0;
        return;
        <D.23175>:
        goto <D.23180>;
        <D.23173>:
        if (has_parent == 0) goto <D.23181>; else goto <D.23182>;
        <D.23181>:
        D.23150 = ctx->report_error;
        if (D.23150 != 0) goto <D.23183>; else goto <D.23184>;
        <D.23183>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.23185 = monoeg_g_strdup_printf ("Invalid typedef row %d for non-interface type must have a non-null extend field", i);
          vinfo->info.message = D.23185;
          vinfo->exception_type = 3;
          D.23154 = ctx->errors;
          D.23186 = monoeg_g_slist_prepend (D.23154, vinfo);
          ctx->errors = D.23186;
        }
        <D.23184>:
        ctx->valid = 0;
        return;
        <D.23182>:
        <D.23180>:
      }
      <D.23169>:
      <D.18388>:
      i = i + 1;
      <D.18395>:
      D.23187 = table->rows;
      D.23188 = (int) D.23187;
      if (D.23188 > i) goto <D.18394>; else goto <D.18396>;
      <D.18396>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


typedef_is_system_object (struct VerifyContext * ctx, guint32 * data)
{
  gboolean D.23192;
  int iftmp.100;
  struct MonoImage * D.23196;
  int D.23197;
  guint32 * D.23199;
  unsigned int D.23200;
  int D.23201;
  guint32 * D.23203;
  unsigned int D.23204;
  int D.23205;

  D.23196 = ctx->image;
  D.23197 = mono_verifier_is_corlib (D.23196);
  if (D.23197 != 0) goto <D.23198>; else goto <D.23194>;
  <D.23198>:
  D.23199 = data + 8;
  D.23200 = *D.23199;
  D.23201 = string_cmp (ctx, "System", D.23200);
  if (D.23201 == 0) goto <D.23202>; else goto <D.23194>;
  <D.23202>:
  D.23203 = data + 4;
  D.23204 = *D.23203;
  D.23205 = string_cmp (ctx, "Object", D.23204);
  if (D.23205 == 0) goto <D.23206>; else goto <D.23194>;
  <D.23206>:
  iftmp.100 = 1;
  goto <D.23195>;
  <D.23194>:
  iftmp.100 = 0;
  <D.23195>:
  D.23192 = iftmp.100;
  return D.23192;
}


mono_verifier_is_corlib (struct MonoImage * image)
{
  int iftmp.101;
  <unnamed type> D.23209;
  gboolean D.23213;
  int iftmp.102;
  const char * D.23218;
  int D.17773;
  int iftmp.103;
  int D.17769;
  const char[13] * D.23223;
  unsigned char D.23224;
  int D.23225;
  unsigned char D.23226;
  int D.23227;
  const unsigned char * D.23232;
  unsigned char D.23233;
  int D.23234;
  const unsigned char * D.23235;
  unsigned char D.23236;
  int D.23237;
  const unsigned char * D.23242;
  unsigned char D.23243;
  int D.23244;
  const unsigned char * D.23245;
  unsigned char D.23246;
  int D.23247;
  const unsigned char * D.23252;
  unsigned char D.23253;
  int D.23254;
  const unsigned char * D.23255;
  unsigned char D.23256;
  int D.23257;
  gboolean trusted_location;

  D.23209 = mono_security_get_mode ();
  if (D.23209 == 1) goto <D.23210>; else goto <D.23211>;
  <D.23210>:
  iftmp.101 = mono_security_core_clr_is_platform_image (image);
  goto <D.23212>;
  <D.23211>:
  iftmp.101 = 1;
  <D.23212>:
  trusted_location = iftmp.101;
  if (trusted_location != 0) goto <D.23217>; else goto <D.23215>;
  <D.23217>:
  D.23218 = image->module_name;
  if (D.23218 != 0B) goto <D.23219>; else goto <D.23215>;
  <D.23219>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = image->module_name;
      D.23223 = "mscorlib.dll";
      D.23224 = MEM[(const unsigned char *)D.23223];
      D.23225 = (int) D.23224;
      D.23226 = *__s2;
      D.23227 = (int) D.23226;
      __result = D.23225 - D.23227;
      {
        if (__s1_len != 0) goto <D.23228>; else goto <D.23229>;
        <D.23228>:
        if (__result == 0) goto <D.23230>; else goto <D.23231>;
        <D.23230>:
        D.23232 = &MEM[(void *)"mscorlib.dll" + 1B];
        D.23233 = *D.23232;
        D.23234 = (int) D.23233;
        D.23235 = __s2 + 1;
        D.23236 = *D.23235;
        D.23237 = (int) D.23236;
        __result = D.23234 - D.23237;
        if (__s1_len > 1) goto <D.23238>; else goto <D.23239>;
        <D.23238>:
        if (__result == 0) goto <D.23240>; else goto <D.23241>;
        <D.23240>:
        D.23242 = &MEM[(void *)"mscorlib.dll" + 2B];
        D.23243 = *D.23242;
        D.23244 = (int) D.23243;
        D.23245 = __s2 + 2;
        D.23246 = *D.23245;
        D.23247 = (int) D.23246;
        __result = D.23244 - D.23247;
        if (__s1_len > 2) goto <D.23248>; else goto <D.23249>;
        <D.23248>:
        if (__result == 0) goto <D.23250>; else goto <D.23251>;
        <D.23250>:
        D.23252 = &MEM[(void *)"mscorlib.dll" + 3B];
        D.23253 = *D.23252;
        D.23254 = (int) D.23253;
        D.23255 = __s2 + 3;
        D.23256 = *D.23255;
        D.23257 = (int) D.23256;
        __result = D.23254 - D.23257;
        <D.23251>:
        <D.23249>:
        <D.23241>:
        <D.23239>:
        <D.23231>:
        <D.23229>:
      }
      D.17769 = __result;
    }
    iftmp.103 = D.17769;
    goto <D.23258>;
    <D.23222>:
    D.23218 = image->module_name;
    iftmp.103 = __builtin_strcmp ("mscorlib.dll", D.23218);
    <D.23258>:
    D.17773 = iftmp.103;
  }
  if (D.17773 == 0) goto <D.23259>; else goto <D.23215>;
  <D.23259>:
  iftmp.102 = 1;
  goto <D.23216>;
  <D.23215>:
  iftmp.102 = 0;
  <D.23216>:
  D.23213 = iftmp.102;
  return D.23213;
}


string_cmp (struct VerifyContext * ctx, const char * str, guint offset)
{
  int D.23263;
  int D.17751;
  int iftmp.104;
  int D.17750;
  const char[1] * D.23267;
  unsigned char D.23268;
  int D.23269;
  unsigned char D.23270;
  int D.23271;
  const unsigned char * D.23276;
  unsigned char D.23277;
  int D.23278;
  const unsigned char * D.23279;
  unsigned char D.23280;
  int D.23281;
  const unsigned char * D.23286;
  unsigned char D.23287;
  int D.23288;
  const unsigned char * D.23289;
  unsigned char D.23290;
  int D.23291;
  const unsigned char * D.23296;
  unsigned char D.23297;
  int D.23298;
  const unsigned char * D.23299;
  unsigned char D.23300;
  int D.23301;
  unsigned char D.23303;
  int D.17760;
  const char * D.23304;

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

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

      __s2 = str;
      D.23267 = "";
      D.23268 = MEM[(const unsigned char *)D.23267];
      D.23269 = (int) D.23268;
      D.23270 = *__s2;
      D.23271 = (int) D.23270;
      __result = D.23269 - D.23271;
      {
        if (__s2_len != 0) goto <D.23272>; else goto <D.23273>;
        <D.23272>:
        if (__result == 0) goto <D.23274>; else goto <D.23275>;
        <D.23274>:
        D.23276 = &MEM[(void *)"" + 1B];
        D.23277 = *D.23276;
        D.23278 = (int) D.23277;
        D.23279 = __s2 + 1;
        D.23280 = *D.23279;
        D.23281 = (int) D.23280;
        __result = D.23278 - D.23281;
        if (__s2_len > 1) goto <D.23282>; else goto <D.23283>;
        <D.23282>:
        if (__result == 0) goto <D.23284>; else goto <D.23285>;
        <D.23284>:
        D.23286 = &MEM[(void *)"" + 2B];
        D.23287 = *D.23286;
        D.23288 = (int) D.23287;
        D.23289 = __s2 + 2;
        D.23290 = *D.23289;
        D.23291 = (int) D.23290;
        __result = D.23288 - D.23291;
        if (__s2_len > 2) goto <D.23292>; else goto <D.23293>;
        <D.23292>:
        if (__result == 0) goto <D.23294>; else goto <D.23295>;
        <D.23294>:
        D.23296 = &MEM[(void *)"" + 3B];
        D.23297 = *D.23296;
        D.23298 = (int) D.23297;
        D.23299 = __s2 + 3;
        D.23300 = *D.23299;
        D.23301 = (int) D.23300;
        __result = D.23298 - D.23301;
        <D.23295>:
        <D.23293>:
        <D.23285>:
        <D.23283>:
        <D.23275>:
        <D.23273>:
      }
      D.17750 = __result;
    }
    iftmp.104 = -D.17750;
    goto <D.23302>;
    <D.23266>:
    D.23303 = MEM[(const unsigned char * {ref-all})str];
    iftmp.104 = (int) D.23303;
    <D.23302>:
    D.17751 = iftmp.104;
  }
  D.23263 = D.17751;
  return D.23263;
  <D.23262>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.23304 = get_string_ptr (ctx, offset);
    D.17760 = __builtin_strcmp (str, D.23304);
  }
  D.23263 = D.17760;
  return D.23263;
}


verify_field_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.23306;
  unsigned int D.23309;
  int D.23311;
  int D.23312;
  gchar * D.23315;
  struct GSList * D.23316;
  struct GSList * D.23317;
  <unnamed-unsigned:24> D.23318;
  int D.23319;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.23306 = ctx->image;
      table = &D.23306->tables[4];
      i = 0;
      goto <D.18431>;
      <D.18430>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.23309 = data[2];
      if (D.23309 == 0) goto <D.23307>; else goto <D.23310>;
      <D.23310>:
      D.23309 = data[2];
      D.23311 = is_valid_field_signature (ctx, D.23309);
      if (D.23311 == 0) goto <D.23307>; else goto <D.23308>;
      <D.23307>:
      D.23312 = ctx->report_error;
      if (D.23312 != 0) goto <D.23313>; else goto <D.23314>;
      <D.23313>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23309 = data[2];
        D.23315 = monoeg_g_strdup_printf ("Invalid field row %d invalid signature token %08x", i, D.23309);
        vinfo->info.message = D.23315;
        vinfo->exception_type = 3;
        D.23316 = ctx->errors;
        D.23317 = monoeg_g_slist_prepend (D.23316, vinfo);
        ctx->errors = D.23317;
      }
      <D.23314>:
      ctx->valid = 0;
      return;
      <D.23308>:
      i = i + 1;
      <D.18431>:
      D.23318 = table->rows;
      D.23319 = (int) D.23318;
      if (D.23319 > i) goto <D.18430>; else goto <D.18432>;
      <D.18432>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_field_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.23323;
  int D.23326;
  gchar * D.23329;
  struct GSList * D.23330;
  struct GSList * D.23331;
  gboolean D.23332;
  const char * ptr.105;
  unsigned int size.106;
  int D.23335;
  gchar * D.23340;
  struct GSList * D.23341;
  unsigned int signature.107;
  gchar * D.23347;
  struct GSList * D.23348;
  const char * ptr.108;
  guint32 size;
  unsigned int signature;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      signature = 0;
      ptr = 0B;
      D.23323 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.23323 == 0) goto <D.23324>; else goto <D.23325>;
      <D.23324>:
      D.23326 = ctx->report_error;
      if (D.23326 != 0) goto <D.23327>; else goto <D.23328>;
      <D.23327>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23329 = monoeg_strdup ("FieldSig: Could not decode signature header");
        vinfo->info.message = D.23329;
        vinfo->exception_type = 3;
        D.23330 = ctx->errors;
        D.23331 = monoeg_g_slist_prepend (D.23330, vinfo);
        ctx->errors = D.23331;
      }
      <D.23328>:
      ctx->valid = 0;
      D.23332 = 0;
      return D.23332;
      <D.23325>:
      ptr.105 = ptr;
      size.106 = size;
      end = ptr.105 + size.106;
      D.23335 = safe_read (&ptr, end, &signature, 1);
      if (D.23335 == 0) goto <D.23336>; else goto <D.23337>;
      <D.23336>:
      D.23326 = ctx->report_error;
      if (D.23326 != 0) goto <D.23338>; else goto <D.23339>;
      <D.23338>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23340 = monoeg_strdup ("FieldSig: Not enough room for the signature");
        vinfo->info.message = D.23340;
        vinfo->exception_type = 3;
        D.23330 = ctx->errors;
        D.23341 = monoeg_g_slist_prepend (D.23330, vinfo);
        ctx->errors = D.23341;
      }
      <D.23339>:
      ctx->valid = 0;
      D.23332 = 0;
      return D.23332;
      <D.23337>:
      signature.107 = signature;
      if (signature.107 != 6) goto <D.23343>; else goto <D.23344>;
      <D.23343>:
      D.23326 = ctx->report_error;
      if (D.23326 != 0) goto <D.23345>; else goto <D.23346>;
      <D.23345>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        signature.107 = signature;
        D.23347 = monoeg_g_strdup_printf ("FieldSig: Invalid signature %x", signature.107);
        vinfo->info.message = D.23347;
        vinfo->exception_type = 3;
        D.23330 = ctx->errors;
        D.23348 = monoeg_g_slist_prepend (D.23330, vinfo);
        ctx->errors = D.23348;
      }
      <D.23346>:
      ctx->valid = 0;
      D.23332 = 0;
      return D.23332;
      <D.23344>:
      ptr.105 = ptr;
      ptr.108 = ptr.105 + 4294967295;
      ptr = ptr.108;
      D.23332 = parse_field (ctx, &ptr, end);
      return D.23332;
    }
  finally
    {
      size = {CLOBBER};
      signature = {CLOBBER};
      ptr = {CLOBBER};
    }
}


parse_field (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.109;
  int D.23353;
  int D.23356;
  gchar * D.23359;
  struct GSList * D.23360;
  struct GSList * D.23361;
  gboolean D.23362;
  unsigned int signature.110;
  gchar * D.23368;
  struct GSList * D.23369;
  int D.23370;
  int D.23373;
  const char * ptr.111;
  const char * ptr.112;
  const char * ptr;
  unsigned int signature;

  try
    {
      ptr.109 = *_ptr;
      ptr = ptr.109;
      signature = 0;
      D.23353 = safe_read (&ptr, end, &signature, 1);
      if (D.23353 == 0) goto <D.23354>; else goto <D.23355>;
      <D.23354>:
      D.23356 = ctx->report_error;
      if (D.23356 != 0) goto <D.23357>; else goto <D.23358>;
      <D.23357>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23359 = monoeg_strdup ("Field: Not enough room for field signature");
        vinfo->info.message = D.23359;
        vinfo->exception_type = 3;
        D.23360 = ctx->errors;
        D.23361 = monoeg_g_slist_prepend (D.23360, vinfo);
        ctx->errors = D.23361;
      }
      <D.23358>:
      ctx->valid = 0;
      D.23362 = 0;
      return D.23362;
      <D.23355>:
      signature.110 = signature;
      if (signature.110 != 6) goto <D.23364>; else goto <D.23365>;
      <D.23364>:
      D.23356 = ctx->report_error;
      if (D.23356 != 0) goto <D.23366>; else goto <D.23367>;
      <D.23366>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        signature.110 = signature;
        D.23368 = monoeg_g_strdup_printf ("Field: Invalid signature 0x%x, must be 6", signature.110);
        vinfo->info.message = D.23368;
        vinfo->exception_type = 3;
        D.23360 = ctx->errors;
        D.23369 = monoeg_g_slist_prepend (D.23360, vinfo);
        ctx->errors = D.23369;
      }
      <D.23367>:
      ctx->valid = 0;
      D.23362 = 0;
      return D.23362;
      <D.23365>:
      D.23370 = parse_custom_mods (ctx, &ptr, end);
      if (D.23370 == 0) goto <D.23371>; else goto <D.23372>;
      <D.23371>:
      D.23362 = 0;
      return D.23362;
      <D.23372>:
      D.23373 = safe_read (&ptr, end, &signature, 1);
      if (D.23373 != 0) goto <D.23374>; else goto <D.23375>;
      <D.23374>:
      signature.110 = signature;
      if (signature.110 != 16) goto <D.23376>; else goto <D.23377>;
      <D.23376>:
      ptr.111 = ptr;
      ptr.112 = ptr.111 + 4294967295;
      ptr = ptr.112;
      <D.23377>:
      <D.23375>:
      ptr.111 = ptr;
      *_ptr = ptr.111;
      D.23362 = parse_type (ctx, _ptr, end);
      return D.23362;
    }
  finally
    {
      ptr = {CLOBBER};
      signature = {CLOBBER};
    }
}


verify_method_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.23382;
  unsigned int D.23385;
  int D.23387;
  int D.23388;
  gchar * D.23391;
  struct GSList * D.23392;
  struct GSList * D.23393;
  int D.23396;
  gchar * D.23401;
  struct GSList * D.23402;
  <unnamed-unsigned:24> D.23403;
  int D.23404;
  struct MonoTableInfo * table;
  guint32 data[6];
  guint32 rva;
  guint32 locals_token;
  int i;

  try
    {
      D.23382 = ctx->image;
      table = &D.23382->tables[6];
      i = 0;
      goto <D.18511>;
      <D.18510>:
      mono_metadata_decode_row (table, i, &data, 6);
      rva = data[0];
      D.23385 = data[4];
      if (D.23385 == 0) goto <D.23383>; else goto <D.23386>;
      <D.23386>:
      D.23385 = data[4];
      D.23387 = is_valid_method_signature (ctx, D.23385);
      if (D.23387 == 0) goto <D.23383>; else goto <D.23384>;
      <D.23383>:
      D.23388 = ctx->report_error;
      if (D.23388 != 0) goto <D.23389>; else goto <D.23390>;
      <D.23389>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23385 = data[4];
        D.23391 = monoeg_g_strdup_printf ("Invalid method row %d invalid signature token 0x%08x", i, D.23385);
        vinfo->info.message = D.23391;
        vinfo->exception_type = 3;
        D.23392 = ctx->errors;
        D.23393 = monoeg_g_slist_prepend (D.23392, vinfo);
        ctx->errors = D.23393;
      }
      <D.23390>:
      ctx->valid = 0;
      return;
      <D.23384>:
      if (rva != 0) goto <D.23394>; else goto <D.23395>;
      <D.23394>:
      D.23396 = is_valid_method_header (ctx, rva, &locals_token);
      if (D.23396 == 0) goto <D.23397>; else goto <D.23398>;
      <D.23397>:
      D.23388 = ctx->report_error;
      if (D.23388 != 0) goto <D.23399>; else goto <D.23400>;
      <D.23399>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23401 = monoeg_g_strdup_printf ("Invalid method row %d RVA points to an invalid method header", i);
        vinfo->info.message = D.23401;
        vinfo->exception_type = 3;
        D.23392 = ctx->errors;
        D.23402 = monoeg_g_slist_prepend (D.23392, vinfo);
        ctx->errors = D.23402;
      }
      <D.23400>:
      ctx->valid = 0;
      return;
      <D.23398>:
      <D.23395>:
      i = i + 1;
      <D.18511>:
      D.23403 = table->rows;
      D.23404 = (int) D.23403;
      if (D.23404 > i) goto <D.18510>; else goto <D.18512>;
      <D.18512>:
    }
  finally
    {
      data = {CLOBBER};
      locals_token = {CLOBBER};
    }
}


is_valid_method_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.23408;
  int D.23411;
  gchar * D.23414;
  struct GSList * D.23415;
  struct GSList * D.23416;
  gboolean D.23417;
  const char * ptr.113;
  unsigned int size.114;
  guint32 size;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      ptr = 0B;
      D.23408 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.23408 == 0) goto <D.23409>; else goto <D.23410>;
      <D.23409>:
      D.23411 = ctx->report_error;
      if (D.23411 != 0) goto <D.23412>; else goto <D.23413>;
      <D.23412>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23414 = monoeg_strdup ("MethodSig: Could not decode signature header");
        vinfo->info.message = D.23414;
        vinfo->exception_type = 3;
        D.23415 = ctx->errors;
        D.23416 = monoeg_g_slist_prepend (D.23415, vinfo);
        ctx->errors = D.23416;
      }
      <D.23413>:
      ctx->valid = 0;
      D.23417 = 0;
      return D.23417;
      <D.23410>:
      ptr.113 = ptr;
      size.114 = size;
      end = ptr.113 + size.114;
      D.23417 = parse_method_signature (ctx, &ptr, end, 0, 0);
      return D.23417;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


is_valid_method_header (struct VerifyContext * ctx, guint32 rva, guint32 * locals_token)
{
  struct MonoImage * D.23422;
  int D.23425;
  gchar * D.23428;
  struct GSList * D.23429;
  struct GSList * D.23430;
  gboolean D.23431;
  const char * D.23432;
  const char * ptr.115;
  unsigned int D.23434;
  int D.23435;
  gchar * D.23440;
  struct GSList * D.23441;
  unsigned int header.116;
  unsigned int D.23443;
  gchar * D.23446;
  struct GSList * D.23447;
  unsigned int header.117;
  const char * ptr.118;
  const char * D.23452;
  unsigned int D.23454;
  unsigned int ptr.119;
  int end.120;
  int ptr.121;
  int D.23460;
  gchar * D.23461;
  struct GSList * D.23462;
  const char * ptr.122;
  int D.23465;
  gchar * D.23470;
  struct GSList * D.23471;
  unsigned int fat_header.123;
  unsigned int D.23473;
  gchar * D.23478;
  struct GSList * D.23479;
  int D.23480;
  gchar * D.23485;
  struct GSList * D.23486;
  int D.23487;
  gchar * D.23492;
  struct GSList * D.23493;
  int D.23494;
  gchar * D.23499;
  struct GSList * D.23500;
  unsigned int local_vars_tok.124;
  unsigned int D.23504;
  gchar * D.23509;
  struct GSList * D.23510;
  unsigned int D.23511;
  <unnamed-unsigned:24> D.23512;
  unsigned int D.23513;
  gchar * D.23518;
  struct GSList * D.23519;
  gchar * D.23524;
  struct GSList * D.23525;
  unsigned int D.23526;
  gchar * D.23531;
  struct GSList * D.23532;
  unsigned int code_size.125;
  const char * ptr.126;
  unsigned int D.23538;
  gchar * D.23541;
  struct GSList * D.23542;
  unsigned int D.23543;
  const char * ptr.127;
  int D.23547;
  gchar * D.23552;
  struct GSList * D.23553;
  unsigned int section_header.128;
  unsigned int D.23555;
  gchar * D.23560;
  struct GSList * D.23561;
  unsigned int D.23562;
  _Bool D.23563;
  unsigned int D.23564;
  unsigned int iftmp.129;
  gchar * D.23573;
  struct GSList * D.23574;
  sizetype D.23577;
  const char * D.23578;
  unsigned int D.23580;
  unsigned int D.23581;
  gchar * D.23584;
  struct GSList * D.23585;
  unsigned int D.23586;
  unsigned int iftmp.130;
  guint32 iftmp.131;
  unsigned int D.23597;
  guint32 iftmp.132;
  unsigned int D.23604;
  unsigned int D.23605;
  guint32 iftmp.133;
  unsigned int D.23614;
  gchar * D.23615;
  struct GSList * D.23616;
  unsigned char D.23617;
  sizetype iftmp.134;
  const char * ptr.135;
  int D.23623;
  gchar * D.23628;
  struct GSList * D.23629;
  unsigned int class_token.136;
  unsigned int D.23635;
  gchar * D.23642;
  struct GSList * D.23643;
  unsigned int D.23644;
  <unnamed-unsigned:24> D.23645;
  unsigned int D.23646;
  gchar * D.23651;
  struct GSList * D.23652;
  unsigned int D.23653;
  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.23422 = ctx->image;
      offset = mono_cli_rva_image_map (D.23422, rva);
      header = 0;
      fat_header = 0;
      size = 0;
      ptr = 0B;
      *locals_token = 0;
      if (offset == 4294967295) goto <D.23423>; else goto <D.23424>;
      <D.23423>:
      D.23425 = ctx->report_error;
      if (D.23425 != 0) goto <D.23426>; else goto <D.23427>;
      <D.23426>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23428 = monoeg_strdup ("MethodHeader: Invalid RVA");
        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;
      D.23431 = 0;
      return D.23431;
      <D.23424>:
      D.23432 = ctx->data;
      ptr.115 = D.23432 + offset;
      ptr = ptr.115;
      D.23432 = ctx->data;
      D.23434 = ctx->size;
      end = D.23432 + D.23434;
      D.23435 = safe_read (&ptr, end, &header, 1);
      if (D.23435 == 0) goto <D.23436>; else goto <D.23437>;
      <D.23436>:
      D.23425 = ctx->report_error;
      if (D.23425 != 0) goto <D.23438>; else goto <D.23439>;
      <D.23438>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23440 = monoeg_strdup ("MethodHeader: Not enough room for header");
        vinfo->info.message = D.23440;
        vinfo->exception_type = 3;
        D.23429 = ctx->errors;
        D.23441 = monoeg_g_slist_prepend (D.23429, vinfo);
        ctx->errors = D.23441;
      }
      <D.23439>:
      ctx->valid = 0;
      D.23431 = 0;
      return D.23431;
      <D.23437>:
      header.116 = header;
      D.23443 = header.116 & 3;
      switch (D.23443) <default: <D.23463>, case 0: <D.18297>, case 1: <D.18298>, case 2: <D.18300>>
      <D.18297>:
      <D.18298>:
      D.23425 = ctx->report_error;
      if (D.23425 != 0) goto <D.23444>; else goto <D.23445>;
      <D.23444>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        header.116 = header;
        D.23443 = header.116 & 3;
        D.23446 = monoeg_g_strdup_printf ("MethodHeader: Invalid header type 0x%x", D.23443);
        vinfo->info.message = D.23446;
        vinfo->exception_type = 3;
        D.23429 = ctx->errors;
        D.23447 = monoeg_g_slist_prepend (D.23429, vinfo);
        ctx->errors = D.23447;
      }
      <D.23445>:
      ctx->valid = 0;
      D.23431 = 0;
      return D.23431;
      <D.18300>:
      header.116 = header;
      header.117 = header.116 >> 2;
      header = header.117;
      ptr.118 = ptr;
      header.116 = header;
      D.23452 = ptr.118 + header.116;
      if (D.23452 > end) goto <D.23449>; else goto <D.23453>;
      <D.23453>:
      header.116 = header;
      D.23454 = ~header.116;
      ptr.118 = ptr;
      ptr.119 = (unsigned int) ptr.118;
      if (D.23454 < ptr.119) goto <D.23449>; else goto <D.23450>;
      <D.23449>:
      D.23425 = ctx->report_error;
      if (D.23425 != 0) goto <D.23456>; else goto <D.23457>;
      <D.23456>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        header.116 = header;
        end.120 = (int) end;
        ptr.118 = ptr;
        ptr.121 = (int) ptr.118;
        D.23460 = end.120 - ptr.121;
        D.23461 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for method body. Required %d, but only %d is available", header.116, D.23460);
        vinfo->info.message = D.23461;
        vinfo->exception_type = 3;
        D.23429 = ctx->errors;
        D.23462 = monoeg_g_slist_prepend (D.23429, vinfo);
        ctx->errors = D.23462;
      }
      <D.23457>:
      ctx->valid = 0;
      D.23431 = 0;
      return D.23431;
      <D.23450>:
      D.23431 = 1;
      return D.23431;
      <D.23463>:
      ptr.118 = ptr;
      ptr.122 = ptr.118 + 4294967295;
      ptr = ptr.122;
      D.23465 = safe_read (&ptr, end, &fat_header, 2);
      if (D.23465 == 0) goto <D.23466>; else goto <D.23467>;
      <D.23466>:
      D.23425 = ctx->report_error;
      if (D.23425 != 0) goto <D.23468>; else goto <D.23469>;
      <D.23468>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23470 = monoeg_strdup ("MethodHeader: Not enough room for fat header");
        vinfo->info.message = D.23470;
        vinfo->exception_type = 3;
        D.23429 = ctx->errors;
        D.23471 = monoeg_g_slist_prepend (D.23429, vinfo);
        ctx->errors = D.23471;
      }
      <D.23469>:
      ctx->valid = 0;
      D.23431 = 0;
      return D.23431;
      <D.23467>:
      fat_header.123 = fat_header;
      D.23473 = fat_header.123 >> 12;
      size = D.23473 & 15;
      if (size != 3) goto <D.23474>; else goto <D.23475>;
      <D.23474>:
      D.23425 = ctx->report_error;
      if (D.23425 != 0) goto <D.23476>; else goto <D.23477>;
      <D.23476>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23478 = monoeg_strdup ("MethodHeader: header size must be 3");
        vinfo->info.message = D.23478;
        vinfo->exception_type = 3;
        D.23429 = ctx->errors;
        D.23479 = monoeg_g_slist_prepend (D.23429, vinfo);
        ctx->errors = D.23479;
      }
      <D.23477>:
      ctx->valid = 0;
      D.23431 = 0;
      return D.23431;
      <D.23475>:
      D.23480 = safe_read (&ptr, end, &max_stack, 2);
      if (D.23480 == 0) goto <D.23481>; else goto <D.23482>;
      <D.23481>:
      D.23425 = ctx->report_error;
      if (D.23425 != 0) goto <D.23483>; else goto <D.23484>;
      <D.23483>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23485 = monoeg_strdup ("MethodHeader: Not enough room for max stack");
        vinfo->info.message = D.23485;
        vinfo->exception_type = 3;
        D.23429 = ctx->errors;
        D.23486 = monoeg_g_slist_prepend (D.23429, vinfo);
        ctx->errors = D.23486;
      }
      <D.23484>:
      ctx->valid = 0;
      D.23431 = 0;
      return D.23431;
      <D.23482>:
      D.23487 = safe_read (&ptr, end, &code_size, 4);
      if (D.23487 == 0) goto <D.23488>; else goto <D.23489>;
      <D.23488>:
      D.23425 = ctx->report_error;
      if (D.23425 != 0) goto <D.23490>; else goto <D.23491>;
      <D.23490>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23492 = monoeg_strdup ("MethodHeader: Not enough room for code size");
        vinfo->info.message = D.23492;
        vinfo->exception_type = 3;
        D.23429 = ctx->errors;
        D.23493 = monoeg_g_slist_prepend (D.23429, vinfo);
        ctx->errors = D.23493;
      }
      <D.23491>:
      ctx->valid = 0;
      D.23431 = 0;
      return D.23431;
      <D.23489>:
      D.23494 = safe_read (&ptr, end, &local_vars_tok, 4);
      if (D.23494 == 0) goto <D.23495>; else goto <D.23496>;
      <D.23495>:
      D.23425 = ctx->report_error;
      if (D.23425 != 0) goto <D.23497>; else goto <D.23498>;
      <D.23497>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23499 = monoeg_strdup ("MethodHeader: Not enough room for local vars tok");
        vinfo->info.message = D.23499;
        vinfo->exception_type = 3;
        D.23429 = ctx->errors;
        D.23500 = monoeg_g_slist_prepend (D.23429, vinfo);
        ctx->errors = D.23500;
      }
      <D.23498>:
      ctx->valid = 0;
      D.23431 = 0;
      return D.23431;
      <D.23496>:
      local_vars_tok.124 = local_vars_tok;
      if (local_vars_tok.124 != 0) goto <D.23502>; else goto <D.23503>;
      <D.23502>:
      local_vars_tok.124 = local_vars_tok;
      D.23504 = local_vars_tok.124 >> 24;
      if (D.23504 != 17) goto <D.23505>; else goto <D.23506>;
      <D.23505>:
      D.23425 = ctx->report_error;
      if (D.23425 != 0) goto <D.23507>; else goto <D.23508>;
      <D.23507>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        local_vars_tok.124 = local_vars_tok;
        D.23504 = local_vars_tok.124 >> 24;
        D.23509 = monoeg_g_strdup_printf ("MethodHeader: Invalid local vars signature table 0x%x", D.23504);
        vinfo->info.message = D.23509;
        vinfo->exception_type = 3;
        D.23429 = ctx->errors;
        D.23510 = monoeg_g_slist_prepend (D.23429, vinfo);
        ctx->errors = D.23510;
      }
      <D.23508>:
      ctx->valid = 0;
      D.23431 = 0;
      return D.23431;
      <D.23506>:
      local_vars_tok.124 = local_vars_tok;
      D.23511 = local_vars_tok.124 & 16777215;
      D.23422 = ctx->image;
      D.23512 = D.23422->tables[17].rows;
      D.23513 = (unsigned int) D.23512;
      if (D.23511 > D.23513) goto <D.23514>; else goto <D.23515>;
      <D.23514>:
      D.23425 = ctx->report_error;
      if (D.23425 != 0) goto <D.23516>; else goto <D.23517>;
      <D.23516>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        local_vars_tok.124 = local_vars_tok;
        D.23511 = local_vars_tok.124 & 16777215;
        D.23518 = monoeg_g_strdup_printf ("MethodHeader: Invalid local vars signature points to invalid row 0x%x", D.23511);
        vinfo->info.message = D.23518;
        vinfo->exception_type = 3;
        D.23429 = ctx->errors;
        D.23519 = monoeg_g_slist_prepend (D.23429, vinfo);
        ctx->errors = D.23519;
      }
      <D.23517>:
      ctx->valid = 0;
      D.23431 = 0;
      return D.23431;
      <D.23515>:
      local_vars_tok.124 = local_vars_tok;
      D.23511 = local_vars_tok.124 & 16777215;
      if (D.23511 == 0) goto <D.23520>; else goto <D.23521>;
      <D.23520>:
      D.23425 = ctx->report_error;
      if (D.23425 != 0) goto <D.23522>; else goto <D.23523>;
      <D.23522>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23524 = monoeg_g_strdup_printf ("MethodHeader: Invalid local vars signature with zero index");
        vinfo->info.message = D.23524;
        vinfo->exception_type = 3;
        D.23429 = ctx->errors;
        D.23525 = monoeg_g_slist_prepend (D.23429, vinfo);
        ctx->errors = D.23525;
      }
      <D.23523>:
      ctx->valid = 0;
      D.23431 = 0;
      return D.23431;
      <D.23521>:
      local_vars_tok.124 = local_vars_tok;
      D.23511 = local_vars_tok.124 & 16777215;
      *locals_token = D.23511;
      <D.23503>:
      fat_header.123 = fat_header;
      D.23526 = fat_header.123 & 4294905828;
      if (D.23526 != 0) goto <D.23527>; else goto <D.23528>;
      <D.23527>:
      D.23425 = ctx->report_error;
      if (D.23425 != 0) goto <D.23529>; else goto <D.23530>;
      <D.23529>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        fat_header.123 = fat_header;
        D.23526 = fat_header.123 & 4294905828;
        D.23531 = monoeg_g_strdup_printf ("MethodHeader: Invalid fat signature flags %x", D.23526);
        vinfo->info.message = D.23531;
        vinfo->exception_type = 3;
        D.23429 = ctx->errors;
        D.23532 = monoeg_g_slist_prepend (D.23429, vinfo);
        ctx->errors = D.23532;
      }
      <D.23530>:
      ctx->valid = 0;
      D.23431 = 0;
      return D.23431;
      <D.23528>:
      ptr.118 = ptr;
      code_size.125 = code_size;
      ptr.126 = ptr.118 + code_size.125;
      if (ptr.126 > end) goto <D.23533>; else goto <D.23537>;
      <D.23537>:
      code_size.125 = code_size;
      D.23538 = ~code_size.125;
      ptr.118 = ptr;
      ptr.119 = (unsigned int) ptr.118;
      if (D.23538 < ptr.119) goto <D.23533>; else goto <D.23534>;
      <D.23533>:
      D.23425 = ctx->report_error;
      if (D.23425 != 0) goto <D.23539>; else goto <D.23540>;
      <D.23539>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        code_size.125 = code_size;
        D.23541 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for code %d", code_size.125);
        vinfo->info.message = D.23541;
        vinfo->exception_type = 3;
        D.23429 = ctx->errors;
        D.23542 = monoeg_g_slist_prepend (D.23429, vinfo);
        ctx->errors = D.23542;
      }
      <D.23540>:
      ctx->valid = 0;
      D.23431 = 0;
      return D.23431;
      <D.23534>:
      fat_header.123 = fat_header;
      D.23543 = fat_header.123 & 8;
      if (D.23543 == 0) goto <D.23544>; else goto <D.23545>;
      <D.23544>:
      D.23431 = 1;
      return D.23431;
      <D.23545>:
      ptr.118 = ptr;
      code_size.125 = code_size;
      ptr.126 = ptr.118 + code_size.125;
      ptr = ptr.126;
      <D.18332>:
      {
        unsigned int section_header;
        unsigned int section_size;
        gboolean is_fat;

        try
          {
            section_header = 0;
            section_size = 0;
            ptr.118 = ptr;
            ptr.127 = dword_align (ptr.118);
            ptr = ptr.127;
            D.23547 = safe_read (&ptr, end, &section_header, 4);
            if (D.23547 == 0) goto <D.23548>; else goto <D.23549>;
            <D.23548>:
            D.23425 = ctx->report_error;
            if (D.23425 != 0) goto <D.23550>; else goto <D.23551>;
            <D.23550>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.23552 = monoeg_strdup ("MethodHeader: Not enough room for data section header");
              vinfo->info.message = D.23552;
              vinfo->exception_type = 3;
              D.23429 = ctx->errors;
              D.23553 = monoeg_g_slist_prepend (D.23429, vinfo);
              ctx->errors = D.23553;
            }
            <D.23551>:
            ctx->valid = 0;
            D.23431 = 0;
            return D.23431;
            <D.23549>:
            section_header.128 = section_header;
            D.23555 = section_header.128 & 62;
            if (D.23555 != 0) goto <D.23556>; else goto <D.23557>;
            <D.23556>:
            D.23425 = ctx->report_error;
            if (D.23425 != 0) goto <D.23558>; else goto <D.23559>;
            <D.23558>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              section_header.128 = section_header;
              D.23555 = section_header.128 & 62;
              D.23560 = monoeg_g_strdup_printf ("MethodHeader: Invalid section header flags 0x%x", D.23555);
              vinfo->info.message = D.23560;
              vinfo->exception_type = 3;
              D.23429 = ctx->errors;
              D.23561 = monoeg_g_slist_prepend (D.23429, vinfo);
              ctx->errors = D.23561;
            }
            <D.23559>:
            ctx->valid = 0;
            D.23431 = 0;
            return D.23431;
            <D.23557>:
            section_header.128 = section_header;
            D.23562 = section_header.128 & 64;
            D.23563 = D.23562 != 0;
            is_fat = (gboolean) D.23563;
            section_header.128 = section_header;
            D.23564 = section_header.128 >> 8;
            if (is_fat != 0) goto <D.23566>; else goto <D.23567>;
            <D.23566>:
            iftmp.129 = 16777215;
            goto <D.23568>;
            <D.23567>:
            iftmp.129 = 255;
            <D.23568>:
            section_size = D.23564 & iftmp.129;
            if (section_size <= 3) goto <D.23569>; else goto <D.23570>;
            <D.23569>:
            D.23425 = ctx->report_error;
            if (D.23425 != 0) goto <D.23571>; else goto <D.23572>;
            <D.23571>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.23573 = monoeg_g_strdup_printf ("MethodHeader: Section size too small");
              vinfo->info.message = D.23573;
              vinfo->exception_type = 3;
              D.23429 = ctx->errors;
              D.23574 = monoeg_g_slist_prepend (D.23429, vinfo);
              ctx->errors = D.23574;
            }
            <D.23572>:
            ctx->valid = 0;
            D.23431 = 0;
            return D.23431;
            <D.23570>:
            ptr.118 = ptr;
            D.23577 = section_size + 4294967292;
            D.23578 = ptr.118 + D.23577;
            if (D.23578 > end) goto <D.23575>; else goto <D.23579>;
            <D.23579>:
            D.23580 = section_size + 4294967292;
            D.23581 = ~D.23580;
            ptr.118 = ptr;
            ptr.119 = (unsigned int) ptr.118;
            if (D.23581 < ptr.119) goto <D.23575>; else goto <D.23576>;
            <D.23575>:
            D.23425 = ctx->report_error;
            if (D.23425 != 0) goto <D.23582>; else goto <D.23583>;
            <D.23582>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.23584 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for section content %d", section_size);
              vinfo->info.message = D.23584;
              vinfo->exception_type = 3;
              D.23429 = ctx->errors;
              D.23585 = monoeg_g_slist_prepend (D.23429, vinfo);
              ctx->errors = D.23585;
            }
            <D.23583>:
            ctx->valid = 0;
            D.23431 = 0;
            return D.23431;
            <D.23576>:
            section_header.128 = section_header;
            D.23586 = section_header.128 & 1;
            if (D.23586 != 0) goto <D.23587>; else goto <D.23588>;
            <D.23587>:
            {
              guint32 i;
              guint32 clauses;

              if (is_fat != 0) goto <D.23590>; else goto <D.23591>;
              <D.23590>:
              iftmp.130 = 24;
              goto <D.23592>;
              <D.23591>:
              iftmp.130 = 12;
              <D.23592>:
              clauses = section_size / iftmp.130;
              if (is_fat != 0) goto <D.23594>; else goto <D.23595>;
              <D.23594>:
              iftmp.131 = 24;
              goto <D.23596>;
              <D.23595>:
              iftmp.131 = 12;
              <D.23596>:
              D.23597 = iftmp.131 * clauses;
              if (D.23597 != section_size) goto <D.23598>; else goto <D.23599>;
              <D.23598>:
              if (is_fat != 0) goto <D.23601>; else goto <D.23602>;
              <D.23601>:
              iftmp.132 = 24;
              goto <D.23603>;
              <D.23602>:
              iftmp.132 = 12;
              <D.23603>:
              D.23604 = iftmp.132 * clauses;
              D.23605 = D.23604 + 4;
              if (D.23605 != section_size) goto <D.23606>; else goto <D.23607>;
              <D.23606>:
              D.23425 = ctx->report_error;
              if (D.23425 != 0) goto <D.23608>; else goto <D.23609>;
              <D.23608>:
              {
                struct MonoVerifyInfoExtended * vinfo;

                vinfo = monoeg_malloc (12);
                vinfo->info.status = 1;
                if (is_fat != 0) goto <D.23611>; else goto <D.23612>;
                <D.23611>:
                iftmp.133 = 24;
                goto <D.23613>;
                <D.23612>:
                iftmp.133 = 12;
                <D.23613>:
                D.23614 = iftmp.133 * clauses;
                D.23615 = monoeg_g_strdup_printf ("MethodHeader: Invalid EH section size %d, it\'s not of the expected size %d", section_size, D.23614);
                vinfo->info.message = D.23615;
                vinfo->exception_type = 3;
                D.23429 = ctx->errors;
                D.23616 = monoeg_g_slist_prepend (D.23429, vinfo);
                ctx->errors = D.23616;
              }
              <D.23609>:
              ctx->valid = 0;
              D.23431 = 0;
              return D.23431;
              <D.23607>:
              <D.23599>:
              i = 0;
              goto <D.18329>;
              <D.18328>:
              {
                unsigned int flags;
                unsigned int class_token;

                try
                  {
                    ptr.118 = ptr;
                    D.23617 = MEM[(unsigned char *)ptr.118];
                    flags = (unsigned int) D.23617;
                    class_token = 0;
                    ptr.118 = ptr;
                    if (is_fat != 0) goto <D.23619>; else goto <D.23620>;
                    <D.23619>:
                    iftmp.134 = 20;
                    goto <D.23621>;
                    <D.23620>:
                    iftmp.134 = 8;
                    <D.23621>:
                    ptr.135 = ptr.118 + iftmp.134;
                    ptr = ptr.135;
                    D.23623 = safe_read (&ptr, end, &class_token, 4);
                    if (D.23623 == 0) goto <D.23624>; else goto <D.23625>;
                    <D.23624>:
                    D.23425 = ctx->report_error;
                    if (D.23425 != 0) goto <D.23626>; else goto <D.23627>;
                    <D.23626>:
                    {
                      struct MonoVerifyInfoExtended * vinfo;

                      vinfo = monoeg_malloc (12);
                      vinfo->info.status = 1;
                      D.23628 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for section %d", i);
                      vinfo->info.message = D.23628;
                      vinfo->exception_type = 3;
                      D.23429 = ctx->errors;
                      D.23629 = monoeg_g_slist_prepend (D.23429, vinfo);
                      ctx->errors = D.23629;
                    }
                    <D.23627>:
                    ctx->valid = 0;
                    D.23431 = 0;
                    return D.23431;
                    <D.23625>:
                    if (flags == 0) goto <D.23630>; else goto <D.23631>;
                    <D.23630>:
                    class_token.136 = class_token;
                    if (class_token.136 != 0) goto <D.23633>; else goto <D.23634>;
                    <D.23633>:
                    {
                      guint table;

                      class_token.136 = class_token;
                      table = class_token.136 >> 24;
                      D.23635 = table + 4294967295;
                      if (D.23635 > 1) goto <D.23636>; else goto <D.23637>;
                      <D.23636>:
                      if (table != 27) goto <D.23638>; else goto <D.23639>;
                      <D.23638>:
                      D.23425 = ctx->report_error;
                      if (D.23425 != 0) goto <D.23640>; else goto <D.23641>;
                      <D.23640>:
                      {
                        struct MonoVerifyInfoExtended * vinfo;

                        vinfo = monoeg_malloc (12);
                        vinfo->info.status = 1;
                        D.23642 = monoeg_g_strdup_printf ("MethodHeader: Invalid section %d class token table %x", i, table);
                        vinfo->info.message = D.23642;
                        vinfo->exception_type = 3;
                        D.23429 = ctx->errors;
                        D.23643 = monoeg_g_slist_prepend (D.23429, vinfo);
                        ctx->errors = D.23643;
                      }
                      <D.23641>:
                      ctx->valid = 0;
                      D.23431 = 0;
                      return D.23431;
                      <D.23639>:
                      <D.23637>:
                      class_token.136 = class_token;
                      D.23644 = class_token.136 & 16777215;
                      D.23422 = ctx->image;
                      D.23645 = D.23422->tables[table].rows;
                      D.23646 = (unsigned int) D.23645;
                      if (D.23644 > D.23646) goto <D.23647>; else goto <D.23648>;
                      <D.23647>:
                      D.23425 = ctx->report_error;
                      if (D.23425 != 0) goto <D.23649>; else goto <D.23650>;
                      <D.23649>:
                      {
                        struct MonoVerifyInfoExtended * vinfo;

                        vinfo = monoeg_malloc (12);
                        vinfo->info.status = 1;
                        class_token.136 = class_token;
                        D.23644 = class_token.136 & 16777215;
                        D.23651 = monoeg_g_strdup_printf ("MethodHeader: Invalid section %d class token index %x", i, D.23644);
                        vinfo->info.message = D.23651;
                        vinfo->exception_type = 3;
                        D.23429 = ctx->errors;
                        D.23652 = monoeg_g_slist_prepend (D.23429, vinfo);
                        ctx->errors = D.23652;
                      }
                      <D.23650>:
                      ctx->valid = 0;
                      D.23431 = 0;
                      return D.23431;
                      <D.23648>:
                    }
                    <D.23634>:
                    <D.23631>:
                  }
                finally
                  {
                    class_token = {CLOBBER};
                  }
              }
              i = i + 1;
              <D.18329>:
              if (i < clauses) goto <D.18328>; else goto <D.18330>;
              <D.18330>:
            }
            <D.23588>:
            section_header.128 = section_header;
            D.23653 = section_header.128 & 128;
            if (D.23653 == 0) goto <D.18331>; else goto <D.23654>;
            <D.23654>:
          }
        finally
          {
            section_header = {CLOBBER};
          }
      }
      goto <D.18332>;
      <D.18331>:
      D.23431 = 1;
      return D.23431;
    }
  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.23662;
  const char * D.23663;
  unsigned int D.23664;
  unsigned int D.23665;

  D.23663 = ptr + 3;
  D.23664 = (unsigned int) D.23663;
  D.23665 = D.23664 & 4294967292;
  D.23662 = (const char *) D.23665;
  return D.23662;
}


verify_memberref_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.23667;
  unsigned int D.23668;
  int D.23669;
  int D.23672;
  gchar * D.23675;
  struct GSList * D.23676;
  struct GSList * D.23677;
  <unnamed-unsigned:24> D.23678;
  int D.23679;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.23667 = ctx->image;
      table = &D.23667->tables[10];
      i = 0;
      goto <D.18578>;
      <D.18577>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.23668 = data[2];
      D.23669 = is_valid_method_or_field_signature (ctx, D.23668);
      if (D.23669 == 0) goto <D.23670>; else goto <D.23671>;
      <D.23670>:
      D.23672 = ctx->report_error;
      if (D.23672 != 0) goto <D.23673>; else goto <D.23674>;
      <D.23673>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23668 = data[2];
        D.23675 = monoeg_g_strdup_printf ("Invalid MemberRef row %d Signature field  0x%08x", i, D.23668);
        vinfo->info.message = D.23675;
        vinfo->exception_type = 3;
        D.23676 = ctx->errors;
        D.23677 = monoeg_g_slist_prepend (D.23676, vinfo);
        ctx->errors = D.23677;
      }
      <D.23674>:
      ctx->valid = 0;
      return;
      <D.23671>:
      i = i + 1;
      <D.18578>:
      D.23678 = table->rows;
      D.23679 = (int) D.23678;
      if (D.23679 > i) goto <D.18577>; else goto <D.18579>;
      <D.18579>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_method_or_field_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.23683;
  int D.23686;
  gchar * D.23689;
  struct GSList * D.23690;
  struct GSList * D.23691;
  gboolean D.23692;
  const char * ptr.137;
  unsigned int size.138;
  int D.23695;
  gchar * D.23700;
  struct GSList * D.23701;
  const char * ptr.139;
  unsigned int signature.140;
  guint32 size;
  unsigned int signature;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      signature = 0;
      ptr = 0B;
      D.23683 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.23683 == 0) goto <D.23684>; else goto <D.23685>;
      <D.23684>:
      D.23686 = ctx->report_error;
      if (D.23686 != 0) goto <D.23687>; else goto <D.23688>;
      <D.23687>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23689 = monoeg_strdup ("MemberRefSig: Could not decode signature header");
        vinfo->info.message = D.23689;
        vinfo->exception_type = 3;
        D.23690 = ctx->errors;
        D.23691 = monoeg_g_slist_prepend (D.23690, vinfo);
        ctx->errors = D.23691;
      }
      <D.23688>:
      ctx->valid = 0;
      D.23692 = 0;
      return D.23692;
      <D.23685>:
      ptr.137 = ptr;
      size.138 = size;
      end = ptr.137 + size.138;
      D.23695 = safe_read (&ptr, end, &signature, 1);
      if (D.23695 == 0) goto <D.23696>; else goto <D.23697>;
      <D.23696>:
      D.23686 = ctx->report_error;
      if (D.23686 != 0) goto <D.23698>; else goto <D.23699>;
      <D.23698>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23700 = monoeg_strdup ("MemberRefSig: Not enough room for the call conv");
        vinfo->info.message = D.23700;
        vinfo->exception_type = 3;
        D.23690 = ctx->errors;
        D.23701 = monoeg_g_slist_prepend (D.23690, vinfo);
        ctx->errors = D.23701;
      }
      <D.23699>:
      ctx->valid = 0;
      D.23692 = 0;
      return D.23692;
      <D.23697>:
      ptr.137 = ptr;
      ptr.139 = ptr.137 + 4294967295;
      ptr = ptr.139;
      signature.140 = signature;
      if (signature.140 == 6) goto <D.23704>; else goto <D.23705>;
      <D.23704>:
      D.23692 = parse_field (ctx, &ptr, end);
      return D.23692;
      <D.23705>:
      D.23692 = parse_method_signature (ctx, &ptr, end, 1, 0);
      return D.23692;
    }
  finally
    {
      size = {CLOBBER};
      signature = {CLOBBER};
      ptr = {CLOBBER};
    }
}


verify_cattr_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.23708;
  unsigned int D.23709;
  int D.23710;
  int D.23713;
  gchar * D.23716;
  struct GSList * D.23717;
  struct GSList * D.23718;
  unsigned int D.23719;
  unsigned int D.23720;
  gchar * D.23723;
  struct GSList * D.23724;
  int D.23725;
  _Bool D.23726;
  long int D.23727;
  long int D.23728;
  const char * ptr.141;
  unsigned int size.142;
  int D.23733;
  gchar * D.23738;
  struct GSList * D.23739;
  <unnamed-unsigned:24> D.23740;
  int D.23741;
  struct MonoTableInfo * table;
  struct MonoMethod * ctor;
  const char * ptr;
  guint32 data[3];
  guint32 mtoken;
  guint32 size;
  int i;

  try
    {
      D.23708 = ctx->image;
      table = &D.23708->tables[12];
      i = 0;
      goto <D.18624>;
      <D.18623>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.23709 = data[2];
      D.23710 = is_valid_cattr_blob (ctx, D.23709);
      if (D.23710 == 0) goto <D.23711>; else goto <D.23712>;
      <D.23711>:
      D.23713 = ctx->report_error;
      if (D.23713 != 0) goto <D.23714>; else goto <D.23715>;
      <D.23714>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23709 = data[2];
        D.23716 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d Value field 0x%08x", i, D.23709);
        vinfo->info.message = D.23716;
        vinfo->exception_type = 3;
        D.23717 = ctx->errors;
        D.23718 = monoeg_g_slist_prepend (D.23717, vinfo);
        ctx->errors = D.23718;
      }
      <D.23715>:
      ctx->valid = 0;
      return;
      <D.23712>:
      D.23719 = data[1];
      mtoken = D.23719 >> 3;
      D.23719 = data[1];
      D.23720 = D.23719 & 7;
      switch (D.23720) <default: <D.18620>, case 2: <D.18617>, case 3: <D.18619>>
      <D.18617>:
      mtoken = mtoken | 100663296;
      goto <D.18618>;
      <D.18619>:
      mtoken = mtoken | 167772160;
      goto <D.18618>;
      <D.18620>:
      D.23713 = ctx->report_error;
      if (D.23713 != 0) goto <D.23721>; else goto <D.23722>;
      <D.23721>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23719 = data[1];
        D.23723 = monoeg_g_strdup_printf ("Invalid CustomAttribute constructor row %d Token 0x%08x", i, D.23719);
        vinfo->info.message = D.23723;
        vinfo->exception_type = 3;
        D.23717 = ctx->errors;
        D.23724 = monoeg_g_slist_prepend (D.23717, vinfo);
        ctx->errors = D.23724;
      }
      <D.23722>:
      ctx->valid = 0;
      return;
      <D.18618>:
      D.23708 = ctx->image;
      ctor = mono_get_method (D.23708, mtoken, 0B);
      D.23709 = data[2];
      D.23725 = decode_signature_header (ctx, D.23709, &size, &ptr);
      D.23726 = D.23725 == 0;
      D.23727 = (long int) D.23726;
      D.23728 = __builtin_expect (D.23727, 0);
      if (D.23728 != 0) goto <D.23729>; else goto <D.23730>;
      <D.23729>:
      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.23730>:
      ptr.141 = ptr;
      size.142 = size;
      D.23733 = is_valid_cattr_content (ctx, ctor, ptr.141, size.142);
      if (D.23733 == 0) goto <D.23734>; else goto <D.23735>;
      <D.23734>:
      D.23713 = ctx->report_error;
      if (D.23713 != 0) goto <D.23736>; else goto <D.23737>;
      <D.23736>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23709 = data[2];
        D.23738 = monoeg_g_strdup_printf ("Invalid CustomAttribute content row %d Value field 0x%08x", i, D.23709);
        vinfo->info.message = D.23738;
        vinfo->exception_type = 3;
        D.23717 = ctx->errors;
        D.23739 = monoeg_g_slist_prepend (D.23717, vinfo);
        ctx->errors = D.23739;
      }
      <D.23737>:
      ctx->valid = 0;
      return;
      <D.23735>:
      i = i + 1;
      <D.18624>:
      D.23740 = table->rows;
      D.23741 = (int) D.23740;
      if (D.23741 > i) goto <D.18623>; else goto <D.18625>;
      <D.18625>:
    }
  finally
    {
      ptr = {CLOBBER};
      data = {CLOBBER};
      size = {CLOBBER};
    }
}


is_valid_cattr_blob (struct VerifyContext * ctx, guint32 offset)
{
  gboolean D.23747;
  int D.23748;
  int D.23751;
  gchar * D.23754;
  struct GSList * D.23755;
  struct GSList * D.23756;
  const char * ptr.143;
  unsigned int size.144;
  int D.23759;
  gchar * D.23764;
  struct GSList * D.23765;
  unsigned int prolog.145;
  gchar * D.23771;
  struct GSList * D.23772;
  guint32 size;
  unsigned int prolog;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      prolog = 0;
      ptr = 0B;
      if (offset == 0) goto <D.23745>; else goto <D.23746>;
      <D.23745>:
      D.23747 = 1;
      return D.23747;
      <D.23746>:
      D.23748 = decode_signature_header (ctx, offset, &size, &ptr);
      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.23754 = monoeg_strdup ("CustomAttribute: Could not decode signature header");
        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;
      D.23747 = 0;
      return D.23747;
      <D.23750>:
      ptr.143 = ptr;
      size.144 = size;
      end = ptr.143 + size.144;
      D.23759 = safe_read (&ptr, end, &prolog, 2);
      if (D.23759 == 0) goto <D.23760>; else goto <D.23761>;
      <D.23760>:
      D.23751 = ctx->report_error;
      if (D.23751 != 0) goto <D.23762>; else goto <D.23763>;
      <D.23762>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23764 = monoeg_strdup ("CustomAttribute: Not enough room for prolog");
        vinfo->info.message = D.23764;
        vinfo->exception_type = 3;
        D.23755 = ctx->errors;
        D.23765 = monoeg_g_slist_prepend (D.23755, vinfo);
        ctx->errors = D.23765;
      }
      <D.23763>:
      ctx->valid = 0;
      D.23747 = 0;
      return D.23747;
      <D.23761>:
      prolog.145 = prolog;
      if (prolog.145 != 1) goto <D.23767>; else goto <D.23768>;
      <D.23767>:
      D.23751 = ctx->report_error;
      if (D.23751 != 0) goto <D.23769>; else goto <D.23770>;
      <D.23769>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        prolog.145 = prolog;
        D.23771 = monoeg_g_strdup_printf ("CustomAttribute: Prolog is 0x%x, expected 0x1", prolog.145);
        vinfo->info.message = D.23771;
        vinfo->exception_type = 3;
        D.23755 = ctx->errors;
        D.23772 = monoeg_g_slist_prepend (D.23755, vinfo);
        ctx->errors = D.23772;
      }
      <D.23770>:
      ctx->valid = 0;
      D.23747 = 0;
      return D.23747;
      <D.23768>:
      D.23747 = 1;
      return D.23747;
    }
  finally
    {
      size = {CLOBBER};
      prolog = {CLOBBER};
      ptr = {CLOBBER};
    }
}


is_valid_cattr_content (struct VerifyContext * ctx, struct MonoMethod * ctor, const char * ptr, guint32 size)
{
  int D.23777;
  gchar * D.23780;
  struct GSList * D.23781;
  struct GSList * D.23782;
  gboolean D.23783;
  int D.23784;
  const char * D.23789;
  gchar * D.23790;
  struct GSList * D.23791;
  short int D.23794;
  unsigned int D.23796;
  unsigned int D.23797;
  gchar * D.23800;
  struct GSList * D.23801;
  const char * ptr.146;
  int D.23803;
  gchar * D.23808;
  struct GSList * D.23809;
  unsigned int prolog.147;
  gchar * D.23815;
  struct GSList * D.23816;
  short unsigned int D.23817;
  int D.23818;
  int D.23821;
  gchar * D.23826;
  struct GSList * D.23827;
  int D.23828;
  gchar * D.23833;
  struct GSList * D.23834;
  unsigned int kind.148;
  unsigned int D.23836;
  gchar * D.23841;
  struct GSList * D.23842;
  int D.23843;
  gchar * D.23848;
  struct GSList * D.23849;
  unsigned int D.23850;
  unsigned char D.23853;
  struct MonoClass * D.23862;
  struct MonoClass * D.23866;
  int D.23870;
  gchar * D.23875;
  struct GSList * D.23876;
  unsigned int etype.149;
  unsigned int D.23890;
  unsigned char iftmp.150;
  gchar * D.23898;
  struct GSList * D.23899;
  struct MonoClass * D.23900;
  gchar * D.23904;
  struct GSList * D.23905;
  int D.23906;
  int D.23909;
  unsigned int i.151;
  unsigned int num_named.152;
  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.23775>; else goto <D.23776>;
      <D.23775>:
      D.23777 = ctx->report_error;
      if (D.23777 != 0) goto <D.23778>; else goto <D.23779>;
      <D.23778>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23780 = monoeg_strdup ("CustomAttribute: Invalid constructor");
        vinfo->info.message = D.23780;
        vinfo->exception_type = 3;
        D.23781 = ctx->errors;
        D.23782 = monoeg_g_slist_prepend (D.23781, vinfo);
        ctx->errors = D.23782;
      }
      <D.23779>:
      ctx->valid = 0;
      D.23783 = 0;
      return D.23783;
      <D.23776>:
      sig = mono_method_signature_checked (ctor, &error);
      D.23784 = mono_error_ok (&error);
      if (D.23784 == 0) goto <D.23785>; else goto <D.23786>;
      <D.23785>:
      D.23777 = ctx->report_error;
      if (D.23777 != 0) goto <D.23787>; else goto <D.23788>;
      <D.23787>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23789 = mono_error_get_message (&error);
        D.23790 = monoeg_g_strdup_printf ("CustomAttribute: Invalid constructor signature %s", D.23789);
        vinfo->info.message = D.23790;
        vinfo->exception_type = 3;
        D.23781 = ctx->errors;
        D.23791 = monoeg_g_slist_prepend (D.23781, vinfo);
        ctx->errors = D.23791;
      }
      <D.23788>:
      ctx->valid = 0;
      mono_error_cleanup (&error);
      D.23783 = 0;
      return D.23783;
      <D.23786>:
      D.23794 = sig->sentinelpos;
      if (D.23794 != -1) goto <D.23792>; else goto <D.23795>;
      <D.23795>:
      D.23796 = BIT_FIELD_REF <*sig, 32, 64>;
      D.23797 = D.23796 & 4128768;
      if (D.23797 == 327680) goto <D.23792>; else goto <D.23793>;
      <D.23792>:
      D.23777 = ctx->report_error;
      if (D.23777 != 0) goto <D.23798>; else goto <D.23799>;
      <D.23798>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23800 = monoeg_strdup ("CustomAttribute: Constructor cannot have VARAG signature");
        vinfo->info.message = D.23800;
        vinfo->exception_type = 3;
        D.23781 = ctx->errors;
        D.23801 = monoeg_g_slist_prepend (D.23781, vinfo);
        ctx->errors = D.23801;
      }
      <D.23799>:
      ctx->valid = 0;
      D.23783 = 0;
      return D.23783;
      <D.23793>:
      ptr.146 = ptr;
      end = ptr.146 + size;
      D.23803 = safe_read (&ptr, end, &prolog, 2);
      if (D.23803 == 0) goto <D.23804>; else goto <D.23805>;
      <D.23804>:
      D.23777 = ctx->report_error;
      if (D.23777 != 0) goto <D.23806>; else goto <D.23807>;
      <D.23806>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23808 = monoeg_strdup ("CustomAttribute: Not enough room for prolog");
        vinfo->info.message = D.23808;
        vinfo->exception_type = 3;
        D.23781 = ctx->errors;
        D.23809 = monoeg_g_slist_prepend (D.23781, vinfo);
        ctx->errors = D.23809;
      }
      <D.23807>:
      ctx->valid = 0;
      D.23783 = 0;
      return D.23783;
      <D.23805>:
      prolog.147 = prolog;
      if (prolog.147 != 1) goto <D.23811>; else goto <D.23812>;
      <D.23811>:
      D.23777 = ctx->report_error;
      if (D.23777 != 0) goto <D.23813>; else goto <D.23814>;
      <D.23813>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        prolog.147 = prolog;
        D.23815 = monoeg_g_strdup_printf ("CustomAttribute: Prolog is 0x%x, expected 0x1", prolog.147);
        vinfo->info.message = D.23815;
        vinfo->exception_type = 3;
        D.23781 = ctx->errors;
        D.23816 = monoeg_g_slist_prepend (D.23781, vinfo);
        ctx->errors = D.23816;
      }
      <D.23814>:
      ctx->valid = 0;
      D.23783 = 0;
      return D.23783;
      <D.23812>:
      D.23817 = sig->param_count;
      args = (int) D.23817;
      i = 0;
      goto <D.18166>;
      <D.18165>:
      {
        struct MonoType * arg_type;

        arg_type = sig->params[i];
        D.23818 = is_valid_fixed_param (ctx, arg_type, &ptr, end);
        if (D.23818 == 0) goto <D.23819>; else goto <D.23820>;
        <D.23819>:
        D.23783 = 0;
        return D.23783;
        <D.23820>:
      }
      i = i + 1;
      <D.18166>:
      if (i < args) goto <D.18165>; else goto <D.18167>;
      <D.18167>:
      D.23821 = safe_read (&ptr, end, &num_named, 2);
      if (D.23821 == 0) goto <D.23822>; else goto <D.23823>;
      <D.23822>:
      D.23777 = ctx->report_error;
      if (D.23777 != 0) goto <D.23824>; else goto <D.23825>;
      <D.23824>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23826 = monoeg_strdup ("CustomAttribute: Not enough space for num_named field");
        vinfo->info.message = D.23826;
        vinfo->exception_type = 3;
        D.23781 = ctx->errors;
        D.23827 = monoeg_g_slist_prepend (D.23781, vinfo);
        ctx->errors = D.23827;
      }
      <D.23825>:
      ctx->valid = 0;
      D.23783 = 0;
      return D.23783;
      <D.23823>:
      i = 0;
      goto <D.18182>;
      <D.18181>:
      {
        struct MonoType * type;
        struct MonoType simple_type;
        unsigned int kind;

        try
          {
            simple_type = {};
            D.23828 = safe_read (&ptr, end, &kind, 1);
            if (D.23828 == 0) goto <D.23829>; else goto <D.23830>;
            <D.23829>:
            D.23777 = ctx->report_error;
            if (D.23777 != 0) goto <D.23831>; else goto <D.23832>;
            <D.23831>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.23833 = monoeg_g_strdup_printf ("CustomAttribute: Not enough space for named parameter %d kind", i);
              vinfo->info.message = D.23833;
              vinfo->exception_type = 3;
              D.23781 = ctx->errors;
              D.23834 = monoeg_g_slist_prepend (D.23781, vinfo);
              ctx->errors = D.23834;
            }
            <D.23832>:
            ctx->valid = 0;
            D.23783 = 0;
            return D.23783;
            <D.23830>:
            kind.148 = kind;
            D.23836 = kind.148 + 4294967213;
            if (D.23836 > 1) goto <D.23837>; else goto <D.23838>;
            <D.23837>:
            D.23777 = ctx->report_error;
            if (D.23777 != 0) goto <D.23839>; else goto <D.23840>;
            <D.23839>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              kind.148 = kind;
              D.23841 = monoeg_g_strdup_printf ("CustomAttribute: Invalid named parameter %d kind %x", i, kind.148);
              vinfo->info.message = D.23841;
              vinfo->exception_type = 3;
              D.23781 = ctx->errors;
              D.23842 = monoeg_g_slist_prepend (D.23781, vinfo);
              ctx->errors = D.23842;
            }
            <D.23840>:
            ctx->valid = 0;
            D.23783 = 0;
            return D.23783;
            <D.23838>:
            D.23843 = safe_read (&ptr, end, &kind, 1);
            if (D.23843 == 0) goto <D.23844>; else goto <D.23845>;
            <D.23844>:
            D.23777 = ctx->report_error;
            if (D.23777 != 0) goto <D.23846>; else goto <D.23847>;
            <D.23846>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.23848 = monoeg_g_strdup_printf ("CustomAttribute: Not enough space for named parameter %d type", i);
              vinfo->info.message = D.23848;
              vinfo->exception_type = 3;
              D.23781 = ctx->errors;
              D.23849 = monoeg_g_slist_prepend (D.23781, vinfo);
              ctx->errors = D.23849;
            }
            <D.23847>:
            ctx->valid = 0;
            D.23783 = 0;
            return D.23783;
            <D.23845>:
            kind.148 = kind;
            D.23850 = kind.148 + 4294967294;
            if (D.23850 <= 12) goto <D.23851>; else goto <D.23852>;
            <D.23851>:
            kind.148 = kind;
            D.23853 = (unsigned char) kind.148;
            simple_type.type = D.23853;
            type = &simple_type;
            goto <D.23854>;
            <D.23852>:
            kind.148 = kind;
            if (kind.148 == 85) goto <D.23855>; else goto <D.23856>;
            <D.23855>:
            {
              struct MonoClass * klass;

              klass = get_enum_by_encoded_name (ctx, &ptr, end);
              if (klass == 0B) goto <D.23857>; else goto <D.23858>;
              <D.23857>:
              D.23783 = 0;
              return D.23783;
              <D.23858>:
              type = &klass->byval_arg;
            }
            goto <D.23859>;
            <D.23856>:
            kind.148 = kind;
            if (kind.148 == 80) goto <D.23860>; else goto <D.23861>;
            <D.23860>:
            D.23862 = mono_defaults.systemtype_class;
            type = &D.23862->byval_arg;
            goto <D.23863>;
            <D.23861>:
            kind.148 = kind;
            if (kind.148 == 81) goto <D.23864>; else goto <D.23865>;
            <D.23864>:
            D.23866 = mono_defaults.object_class;
            type = &D.23866->byval_arg;
            goto <D.23867>;
            <D.23865>:
            kind.148 = kind;
            if (kind.148 == 29) goto <D.23868>; else goto <D.23869>;
            <D.23868>:
            {
              struct MonoClass * klass;
              unsigned int etype;

              try
                {
                  etype = 0;
                  D.23870 = safe_read (&ptr, end, &etype, 1);
                  if (D.23870 == 0) goto <D.23871>; else goto <D.23872>;
                  <D.23871>:
                  D.23777 = ctx->report_error;
                  if (D.23777 != 0) goto <D.23873>; else goto <D.23874>;
                  <D.23873>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (12);
                    vinfo->info.status = 1;
                    D.23875 = monoeg_strdup ("CustomAttribute: Not enough room for array element type");
                    vinfo->info.message = D.23875;
                    vinfo->exception_type = 3;
                    D.23781 = ctx->errors;
                    D.23876 = monoeg_g_slist_prepend (D.23781, vinfo);
                    ctx->errors = D.23876;
                  }
                  <D.23874>:
                  ctx->valid = 0;
                  D.23783 = 0;
                  return D.23783;
                  <D.23872>:
                  etype.149 = etype;
                  if (etype.149 == 85) goto <D.23878>; else goto <D.23879>;
                  <D.23878>:
                  klass = get_enum_by_encoded_name (ctx, &ptr, end);
                  if (klass == 0B) goto <D.23880>; else goto <D.23881>;
                  <D.23880>:
                  D.23783 = 0;
                  return D.23783;
                  <D.23881>:
                  goto <D.23882>;
                  <D.23879>:
                  etype.149 = etype;
                  if (etype.149 == 80) goto <D.23883>; else goto <D.23886>;
                  <D.23886>:
                  etype.149 = etype;
                  if (etype.149 == 18) goto <D.23883>; else goto <D.23884>;
                  <D.23883>:
                  klass = mono_defaults.systemtype_class;
                  goto <D.23885>;
                  <D.23884>:
                  etype.149 = etype;
                  D.23890 = etype.149 + 4294967294;
                  if (D.23890 <= 12) goto <D.23887>; else goto <D.23891>;
                  <D.23891>:
                  etype.149 = etype;
                  if (etype.149 == 81) goto <D.23887>; else goto <D.23888>;
                  <D.23887>:
                  etype.149 = etype;
                  if (etype.149 != 81) goto <D.23893>; else goto <D.23894>;
                  <D.23893>:
                  etype.149 = etype;
                  iftmp.150 = (unsigned char) etype.149;
                  goto <D.23895>;
                  <D.23894>:
                  iftmp.150 = 28;
                  <D.23895>:
                  simple_type.type = iftmp.150;
                  klass = mono_class_from_mono_type (&simple_type);
                  goto <D.23889>;
                  <D.23888>:
                  D.23777 = ctx->report_error;
                  if (D.23777 != 0) goto <D.23896>; else goto <D.23897>;
                  <D.23896>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (12);
                    vinfo->info.status = 1;
                    etype.149 = etype;
                    D.23898 = monoeg_g_strdup_printf ("CustomAttribute: Invalid array element type %x", etype.149);
                    vinfo->info.message = D.23898;
                    vinfo->exception_type = 3;
                    D.23781 = ctx->errors;
                    D.23899 = monoeg_g_slist_prepend (D.23781, vinfo);
                    ctx->errors = D.23899;
                  }
                  <D.23897>:
                  ctx->valid = 0;
                  D.23783 = 0;
                  return D.23783;
                  <D.23889>:
                  <D.23885>:
                  <D.23882>:
                  D.23900 = mono_array_class_get (klass, 1);
                  type = &D.23900->byval_arg;
                }
              finally
                {
                  etype = {CLOBBER};
                }
            }
            goto <D.23901>;
            <D.23869>:
            D.23777 = ctx->report_error;
            if (D.23777 != 0) goto <D.23902>; else goto <D.23903>;
            <D.23902>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              kind.148 = kind;
              D.23904 = monoeg_g_strdup_printf ("CustomAttribute: Invalid named parameter type %x", kind.148);
              vinfo->info.message = D.23904;
              vinfo->exception_type = 3;
              D.23781 = ctx->errors;
              D.23905 = monoeg_g_slist_prepend (D.23781, vinfo);
              ctx->errors = D.23905;
            }
            <D.23903>:
            ctx->valid = 0;
            D.23783 = 0;
            return D.23783;
            <D.23901>:
            <D.23867>:
            <D.23863>:
            <D.23859>:
            <D.23854>:
            D.23906 = is_valid_ser_string (ctx, &ptr, end);
            if (D.23906 == 0) goto <D.23907>; else goto <D.23908>;
            <D.23907>:
            D.23783 = 0;
            return D.23783;
            <D.23908>:
            D.23909 = is_valid_fixed_param (ctx, type, &ptr, end);
            if (D.23909 == 0) goto <D.23910>; else goto <D.23911>;
            <D.23910>:
            D.23783 = 0;
            return D.23783;
            <D.23911>:
          }
        finally
          {
            simple_type = {CLOBBER};
            kind = {CLOBBER};
          }
      }
      i = i + 1;
      <D.18182>:
      i.151 = (unsigned int) i;
      num_named.152 = num_named;
      if (i.151 < num_named.152) goto <D.18181>; else goto <D.18183>;
      <D.18183>:
      D.23783 = 1;
      return D.23783;
    }
  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.153;
  int D.23921;
  struct MonoClass * D.23924;
  const char * str_start.154;
  unsigned int str_len.155;
  int D.23930;
  gchar * D.23933;
  struct GSList * D.23934;
  struct GSList * D.23935;
  unsigned int D.23936;
  char * D.23937;
  struct MonoImage * D.23938;
  gchar * D.23943;
  struct GSList * D.23944;
  unsigned int D.23948;
  unsigned int D.23949;
  const char * D.23952;
  const char * D.23953;
  gchar * D.23954;
  struct GSList * D.23955;
  const char * ptr.156;
  struct MonoType * type;
  struct MonoClass * klass;
  const char * str_start;
  const char * ptr;
  char * enum_name;
  guint32 str_len;

  try
    {
      str_start = 0B;
      ptr.153 = *_ptr;
      ptr = ptr.153;
      str_len = 0;
      D.23921 = is_valid_ser_string_full (ctx, &str_start, &str_len, &ptr, end);
      if (D.23921 == 0) goto <D.23922>; else goto <D.23923>;
      <D.23922>:
      D.23924 = 0B;
      return D.23924;
      <D.23923>:
      str_start.154 = str_start;
      if (str_start.154 == 0B) goto <D.23925>; else goto <D.23928>;
      <D.23928>:
      str_len.155 = str_len;
      if (str_len.155 == 0) goto <D.23925>; else goto <D.23926>;
      <D.23925>:
      D.23930 = ctx->report_error;
      if (D.23930 != 0) goto <D.23931>; else goto <D.23932>;
      <D.23931>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23933 = monoeg_strdup ("CustomAttribute: Null or empty enum name");
        vinfo->info.message = D.23933;
        vinfo->exception_type = 3;
        D.23934 = ctx->errors;
        D.23935 = monoeg_g_slist_prepend (D.23934, vinfo);
        ctx->errors = D.23935;
      }
      <D.23932>:
      ctx->valid = 0;
      D.23924 = 0B;
      return D.23924;
      <D.23926>:
      str_start.154 = str_start;
      str_len.155 = str_len;
      D.23936 = str_len.155 + 1;
      enum_name = monoeg_g_memdup (str_start.154, D.23936);
      str_len.155 = str_len;
      D.23937 = enum_name + str_len.155;
      *D.23937 = 0;
      D.23938 = ctx->image;
      type = mono_reflection_type_from_name (enum_name, D.23938);
      if (type == 0B) goto <D.23939>; else goto <D.23940>;
      <D.23939>:
      D.23930 = ctx->report_error;
      if (D.23930 != 0) goto <D.23941>; else goto <D.23942>;
      <D.23941>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23943 = monoeg_g_strdup_printf ("CustomAttribute: Invalid enum class %s", enum_name);
        vinfo->info.message = D.23943;
        vinfo->exception_type = 3;
        D.23934 = ctx->errors;
        D.23944 = monoeg_g_slist_prepend (D.23934, vinfo);
        ctx->errors = D.23944;
      }
      <D.23942>:
      ctx->valid = 0;
      monoeg_g_free (enum_name);
      D.23924 = 0B;
      return D.23924;
      <D.23940>:
      monoeg_g_free (enum_name);
      klass = mono_class_from_mono_type (type);
      if (klass == 0B) goto <D.23945>; else goto <D.23947>;
      <D.23947>:
      D.23948 = BIT_FIELD_REF <*klass, 32, 160>;
      D.23949 = D.23948 & 16;
      if (D.23949 == 0) goto <D.23945>; else goto <D.23946>;
      <D.23945>:
      D.23930 = ctx->report_error;
      if (D.23930 != 0) goto <D.23950>; else goto <D.23951>;
      <D.23950>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23952 = klass->name_space;
        D.23953 = klass->name;
        D.23954 = monoeg_g_strdup_printf ("CustomAttribute:Class %s::%s is not an enum", D.23952, D.23953);
        vinfo->info.message = D.23954;
        vinfo->exception_type = 3;
        D.23934 = ctx->errors;
        D.23955 = monoeg_g_slist_prepend (D.23934, vinfo);
        ctx->errors = D.23955;
      }
      <D.23951>:
      ctx->valid = 0;
      D.23924 = 0B;
      return D.23924;
      <D.23946>:
      ptr.156 = ptr;
      *_ptr = ptr.156;
      D.23924 = klass;
      return D.23924;
    }
  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.157;
  const char * ptr.158;
  int D.23963;
  gchar * D.23966;
  struct GSList * D.23967;
  struct GSList * D.23968;
  gboolean D.23969;
  char D.23970;
  const char * D.23973;
  int D.23974;
  gchar * D.23979;
  struct GSList * D.23980;
  unsigned int size.159;
  const char * D.23984;
  unsigned int D.23986;
  unsigned int ptr.160;
  gchar * D.23990;
  struct GSList * D.23991;
  guint32 size;
  const char * ptr;

  try
    {
      size = 0;
      ptr.157 = *_ptr;
      ptr = ptr.157;
      *str_start = 0B;
      *str_len = 0;
      ptr.158 = ptr;
      if (ptr.158 >= end) goto <D.23961>; else goto <D.23962>;
      <D.23961>:
      D.23963 = ctx->report_error;
      if (D.23963 != 0) goto <D.23964>; else goto <D.23965>;
      <D.23964>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23966 = monoeg_strdup ("CustomAttribute: Not enough room for string size");
        vinfo->info.message = D.23966;
        vinfo->exception_type = 3;
        D.23967 = ctx->errors;
        D.23968 = monoeg_g_slist_prepend (D.23967, vinfo);
        ctx->errors = D.23968;
      }
      <D.23965>:
      ctx->valid = 0;
      D.23969 = 0;
      return D.23969;
      <D.23962>:
      ptr.158 = ptr;
      D.23970 = *ptr.158;
      if (D.23970 == -1) goto <D.23971>; else goto <D.23972>;
      <D.23971>:
      ptr.158 = ptr;
      D.23973 = ptr.158 + 1;
      *_ptr = D.23973;
      D.23969 = 1;
      return D.23969;
      <D.23972>:
      D.23974 = safe_read_compressed_int (&ptr, end, &size);
      if (D.23974 == 0) goto <D.23975>; else goto <D.23976>;
      <D.23975>:
      D.23963 = ctx->report_error;
      if (D.23963 != 0) goto <D.23977>; else goto <D.23978>;
      <D.23977>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23979 = monoeg_strdup ("CustomAttribute: Not enough room for string size");
        vinfo->info.message = D.23979;
        vinfo->exception_type = 3;
        D.23967 = ctx->errors;
        D.23980 = monoeg_g_slist_prepend (D.23967, vinfo);
        ctx->errors = D.23980;
      }
      <D.23978>:
      ctx->valid = 0;
      D.23969 = 0;
      return D.23969;
      <D.23976>:
      ptr.158 = ptr;
      size.159 = size;
      D.23984 = ptr.158 + size.159;
      if (D.23984 > end) goto <D.23981>; else goto <D.23985>;
      <D.23985>:
      size.159 = size;
      D.23986 = ~size.159;
      ptr.158 = ptr;
      ptr.160 = (unsigned int) ptr.158;
      if (D.23986 < ptr.160) goto <D.23981>; else goto <D.23982>;
      <D.23981>:
      D.23963 = ctx->report_error;
      if (D.23963 != 0) goto <D.23988>; else goto <D.23989>;
      <D.23988>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23990 = monoeg_strdup ("CustomAttribute: Not enough room for string");
        vinfo->info.message = D.23990;
        vinfo->exception_type = 3;
        D.23967 = ctx->errors;
        D.23991 = monoeg_g_slist_prepend (D.23967, vinfo);
        ctx->errors = D.23991;
      }
      <D.23989>:
      ctx->valid = 0;
      D.23969 = 0;
      return D.23969;
      <D.23982>:
      ptr.158 = ptr;
      *str_start = ptr.158;
      size.159 = size;
      *str_len = size.159;
      ptr.158 = ptr;
      size.159 = size;
      D.23984 = ptr.158 + size.159;
      *_ptr = D.23984;
      D.23969 = 1;
      return D.23969;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


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

  try
    {
      D.23994 = is_valid_ser_string_full (ctx, &dummy_str, &dummy_int, _ptr, end);
      return D.23994;
    }
  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.161;
  unsigned char D.23998;
  const char * ptr.162;
  gboolean D.24000;
  int D.24001;
  int D.24004;
  gchar * D.24007;
  struct GSList * D.24008;
  struct GSList * D.24009;
  unsigned int sub_type.163;
  unsigned int D.24011;
  unsigned char D.24018;
  int D.24023;
  gchar * D.24028;
  struct GSList * D.24029;
  unsigned int etype.164;
  unsigned int D.24043;
  unsigned char iftmp.165;
  gchar * D.24051;
  struct GSList * D.24052;
  gchar * D.24055;
  struct GSList * D.24056;
  struct MonoClass * D.24057;
  const char * D.24062;
  const char * D.24063;
  gchar * D.24064;
  struct GSList * D.24065;
  unsigned int D.24069;
  unsigned int D.24070;
  gchar * D.24073;
  struct GSList * D.24074;
  int D.24075;
  gchar * D.24080;
  struct GSList * D.24081;
  int D.24082;
  gchar * D.24087;
  struct GSList * D.24088;
  unsigned int element_count.166;
  int D.24092;
  gchar * D.24097;
  struct GSList * D.24098;
  sizetype elem_size.167;
  const char * D.24102;
  unsigned int elem_size.168;
  unsigned int D.24105;
  unsigned int ptr.169;
  gchar * D.24109;
  struct GSList * D.24110;
  struct MonoClass * klass;
  const char * ptr;
  int elem_size;
  guint32 element_count;
  guint32 i;
  int type;
  void handle_enum = <<< error >>>;

  try
    {
      ptr.161 = *_ptr;
      ptr = ptr.161;
      elem_size = 0;
      klass = mono_type->data.klass;
      D.23998 = mono_type->type;
      type = (int) D.23998;
      handle_enum:
      switch (type) <default: <D.18143>, case 2: <D.18111>, case 3: <D.18117>, case 4: <D.18112>, case 5: <D.18113>, case 6: <D.18115>, case 7: <D.18116>, case 8: <D.18118>, case 9: <D.18119>, case 10: <D.18121>, case 11: <D.18122>, case 12: <D.18120>, case 13: <D.18123>, case 14: <D.18124>, case 17: <D.18135>, case 18: <D.18133>, case 28: <D.18125>, case 29: <D.18137>>
      <D.18111>:
      <D.18112>:
      <D.18113>:
      elem_size = 1;
      goto <D.18114>;
      <D.18115>:
      <D.18116>:
      <D.18117>:
      elem_size = 2;
      goto <D.18114>;
      <D.18118>:
      <D.18119>:
      <D.18120>:
      elem_size = 4;
      goto <D.18114>;
      <D.18121>:
      <D.18122>:
      <D.18123>:
      elem_size = 8;
      goto <D.18114>;
      <D.18124>:
      ptr.162 = ptr;
      *_ptr = ptr.162;
      D.24000 = is_valid_ser_string (ctx, _ptr, end);
      return D.24000;
      <D.18125>:
      {
        unsigned int sub_type;

        try
          {
            sub_type = 0;
            D.24001 = safe_read (&ptr, end, &sub_type, 1);
            if (D.24001 == 0) goto <D.24002>; else goto <D.24003>;
            <D.24002>:
            D.24004 = ctx->report_error;
            if (D.24004 != 0) goto <D.24005>; else goto <D.24006>;
            <D.24005>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.24007 = monoeg_strdup ("CustomAttribute: Not enough room for array type");
              vinfo->info.message = D.24007;
              vinfo->exception_type = 3;
              D.24008 = ctx->errors;
              D.24009 = monoeg_g_slist_prepend (D.24008, vinfo);
              ctx->errors = D.24009;
            }
            <D.24006>:
            ctx->valid = 0;
            D.24000 = 0;
            return D.24000;
            <D.24003>:
            sub_type.163 = sub_type;
            D.24011 = sub_type.163 + 4294967294;
            if (D.24011 <= 12) goto <D.24012>; else goto <D.24013>;
            <D.24012>:
            sub_type.163 = sub_type;
            type = (int) sub_type.163;
            goto handle_enum;
            <D.24013>:
            sub_type.163 = sub_type;
            if (sub_type.163 == 85) goto <D.24014>; else goto <D.24015>;
            <D.24014>:
            klass = get_enum_by_encoded_name (ctx, &ptr, end);
            if (klass == 0B) goto <D.24016>; else goto <D.24017>;
            <D.24016>:
            D.24000 = 0;
            return D.24000;
            <D.24017>:
            klass = klass->element_class;
            D.24018 = klass->byval_arg.type;
            type = (int) D.24018;
            goto handle_enum;
            <D.24015>:
            sub_type.163 = sub_type;
            if (sub_type.163 == 80) goto <D.24019>; else goto <D.24020>;
            <D.24019>:
            ptr.162 = ptr;
            *_ptr = ptr.162;
            D.24000 = is_valid_ser_string (ctx, _ptr, end);
            return D.24000;
            <D.24020>:
            sub_type.163 = sub_type;
            if (sub_type.163 == 29) goto <D.24021>; else goto <D.24022>;
            <D.24021>:
            {
              struct MonoType simple_type;
              unsigned int etype;

              try
                {
                  simple_type = {};
                  etype = 0;
                  D.24023 = safe_read (&ptr, end, &etype, 1);
                  if (D.24023 == 0) goto <D.24024>; else goto <D.24025>;
                  <D.24024>:
                  D.24004 = ctx->report_error;
                  if (D.24004 != 0) goto <D.24026>; else goto <D.24027>;
                  <D.24026>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (12);
                    vinfo->info.status = 1;
                    D.24028 = monoeg_strdup ("CustomAttribute: Not enough room for array element type");
                    vinfo->info.message = D.24028;
                    vinfo->exception_type = 3;
                    D.24008 = ctx->errors;
                    D.24029 = monoeg_g_slist_prepend (D.24008, vinfo);
                    ctx->errors = D.24029;
                  }
                  <D.24027>:
                  ctx->valid = 0;
                  D.24000 = 0;
                  return D.24000;
                  <D.24025>:
                  etype.164 = etype;
                  if (etype.164 == 85) goto <D.24031>; else goto <D.24032>;
                  <D.24031>:
                  klass = get_enum_by_encoded_name (ctx, &ptr, end);
                  if (klass == 0B) goto <D.24033>; else goto <D.24034>;
                  <D.24033>:
                  D.24000 = 0;
                  return D.24000;
                  <D.24034>:
                  goto <D.24035>;
                  <D.24032>:
                  etype.164 = etype;
                  if (etype.164 == 80) goto <D.24036>; else goto <D.24039>;
                  <D.24039>:
                  etype.164 = etype;
                  if (etype.164 == 18) goto <D.24036>; else goto <D.24037>;
                  <D.24036>:
                  klass = mono_defaults.systemtype_class;
                  goto <D.24038>;
                  <D.24037>:
                  etype.164 = etype;
                  D.24043 = etype.164 + 4294967294;
                  if (D.24043 <= 12) goto <D.24040>; else goto <D.24044>;
                  <D.24044>:
                  etype.164 = etype;
                  if (etype.164 == 81) goto <D.24040>; else goto <D.24041>;
                  <D.24040>:
                  etype.164 = etype;
                  if (etype.164 != 81) goto <D.24046>; else goto <D.24047>;
                  <D.24046>:
                  etype.164 = etype;
                  iftmp.165 = (unsigned char) etype.164;
                  goto <D.24048>;
                  <D.24047>:
                  iftmp.165 = 28;
                  <D.24048>:
                  simple_type.type = iftmp.165;
                  klass = mono_class_from_mono_type (&simple_type);
                  goto <D.24042>;
                  <D.24041>:
                  D.24004 = ctx->report_error;
                  if (D.24004 != 0) goto <D.24049>; else goto <D.24050>;
                  <D.24049>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (12);
                    vinfo->info.status = 1;
                    etype.164 = etype;
                    D.24051 = monoeg_g_strdup_printf ("CustomAttribute: Invalid array element type %x", etype.164);
                    vinfo->info.message = D.24051;
                    vinfo->exception_type = 3;
                    D.24008 = ctx->errors;
                    D.24052 = monoeg_g_slist_prepend (D.24008, vinfo);
                    ctx->errors = D.24052;
                  }
                  <D.24050>:
                  ctx->valid = 0;
                  D.24000 = 0;
                  return D.24000;
                  <D.24042>:
                  <D.24038>:
                  <D.24035>:
                  type = 29;
                  goto handle_enum;
                }
              finally
                {
                  simple_type = {CLOBBER};
                  etype = {CLOBBER};
                }
            }
            <D.24022>:
            D.24004 = ctx->report_error;
            if (D.24004 != 0) goto <D.24053>; else goto <D.24054>;
            <D.24053>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              sub_type.163 = sub_type;
              D.24055 = monoeg_g_strdup_printf ("CustomAttribute: Invalid boxed object type %x", sub_type.163);
              vinfo->info.message = D.24055;
              vinfo->exception_type = 3;
              D.24008 = ctx->errors;
              D.24056 = monoeg_g_slist_prepend (D.24008, vinfo);
              ctx->errors = D.24056;
            }
            <D.24054>:
            ctx->valid = 0;
            D.24000 = 0;
            return D.24000;
          }
        finally
          {
            sub_type = {CLOBBER};
          }
      }
      <D.18133>:
      D.24057 = mono_defaults.systemtype_class;
      if (D.24057 != klass) goto <D.24058>; else goto <D.24059>;
      <D.24058>:
      D.24004 = ctx->report_error;
      if (D.24004 != 0) goto <D.24060>; else goto <D.24061>;
      <D.24060>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24062 = klass->name_space;
        D.24063 = klass->name;
        D.24064 = monoeg_g_strdup_printf ("CustomAttribute: Invalid class parameter type %s:%s ", D.24062, D.24063);
        vinfo->info.message = D.24064;
        vinfo->exception_type = 3;
        D.24008 = ctx->errors;
        D.24065 = monoeg_g_slist_prepend (D.24008, vinfo);
        ctx->errors = D.24065;
      }
      <D.24061>:
      ctx->valid = 0;
      D.24000 = 0;
      return D.24000;
      <D.24059>:
      ptr.162 = ptr;
      *_ptr = ptr.162;
      D.24000 = is_valid_ser_string (ctx, _ptr, end);
      return D.24000;
      <D.18135>:
      if (klass == 0B) goto <D.24066>; else goto <D.24068>;
      <D.24068>:
      D.24069 = BIT_FIELD_REF <*klass, 32, 160>;
      D.24070 = D.24069 & 16;
      if (D.24070 == 0) goto <D.24066>; else goto <D.24067>;
      <D.24066>:
      D.24004 = ctx->report_error;
      if (D.24004 != 0) goto <D.24071>; else goto <D.24072>;
      <D.24071>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24062 = klass->name_space;
        D.24063 = klass->name;
        D.24073 = monoeg_g_strdup_printf ("CustomAttribute: Invalid valuetype parameter expected enum %s:%s ", D.24062, D.24063);
        vinfo->info.message = D.24073;
        vinfo->exception_type = 3;
        D.24008 = ctx->errors;
        D.24074 = monoeg_g_slist_prepend (D.24008, vinfo);
        ctx->errors = D.24074;
      }
      <D.24072>:
      ctx->valid = 0;
      D.24000 = 0;
      return D.24000;
      <D.24067>:
      klass = klass->element_class;
      D.24018 = klass->byval_arg.type;
      type = (int) D.24018;
      goto handle_enum;
      <D.18137>:
      mono_type = &klass->byval_arg;
      D.24075 = is_valid_cattr_type (mono_type);
      if (D.24075 == 0) goto <D.24076>; else goto <D.24077>;
      <D.24076>:
      D.24004 = ctx->report_error;
      if (D.24004 != 0) goto <D.24078>; else goto <D.24079>;
      <D.24078>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24062 = klass->name_space;
        D.24063 = klass->name;
        D.24080 = monoeg_g_strdup_printf ("CustomAttribute: Invalid array element type %s:%s ", D.24062, D.24063);
        vinfo->info.message = D.24080;
        vinfo->exception_type = 3;
        D.24008 = ctx->errors;
        D.24081 = monoeg_g_slist_prepend (D.24008, vinfo);
        ctx->errors = D.24081;
      }
      <D.24079>:
      ctx->valid = 0;
      D.24000 = 0;
      return D.24000;
      <D.24077>:
      D.24082 = safe_read (&ptr, end, &element_count, 4);
      if (D.24082 == 0) goto <D.24083>; else goto <D.24084>;
      <D.24083>:
      D.24004 = ctx->report_error;
      if (D.24004 != 0) goto <D.24085>; else goto <D.24086>;
      <D.24085>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24062 = klass->name_space;
        D.24063 = klass->name;
        D.24087 = monoeg_g_strdup_printf ("CustomAttribute: Invalid class parameter type %s:%s ", D.24062, D.24063);
        vinfo->info.message = D.24087;
        vinfo->exception_type = 3;
        D.24008 = ctx->errors;
        D.24088 = monoeg_g_slist_prepend (D.24008, vinfo);
        ctx->errors = D.24088;
      }
      <D.24086>:
      ctx->valid = 0;
      D.24000 = 0;
      return D.24000;
      <D.24084>:
      element_count.166 = element_count;
      if (element_count.166 == 4294967295) goto <D.24090>; else goto <D.24091>;
      <D.24090>:
      ptr.162 = ptr;
      *_ptr = ptr.162;
      D.24000 = 1;
      return D.24000;
      <D.24091>:
      i = 0;
      goto <D.18141>;
      <D.18140>:
      D.24092 = is_valid_fixed_param (ctx, mono_type, &ptr, end);
      if (D.24092 == 0) goto <D.24093>; else goto <D.24094>;
      <D.24093>:
      D.24000 = 0;
      return D.24000;
      <D.24094>:
      i = i + 1;
      <D.18141>:
      element_count.166 = element_count;
      if (i < element_count.166) goto <D.18140>; else goto <D.18142>;
      <D.18142>:
      ptr.162 = ptr;
      *_ptr = ptr.162;
      D.24000 = 1;
      return D.24000;
      <D.18143>:
      D.24004 = ctx->report_error;
      if (D.24004 != 0) goto <D.24095>; else goto <D.24096>;
      <D.24095>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24097 = monoeg_g_strdup_printf ("CustomAttribute: Invalid parameter type %x ", type);
        vinfo->info.message = D.24097;
        vinfo->exception_type = 3;
        D.24008 = ctx->errors;
        D.24098 = monoeg_g_slist_prepend (D.24008, vinfo);
        ctx->errors = D.24098;
      }
      <D.24096>:
      ctx->valid = 0;
      D.24000 = 0;
      return D.24000;
      <D.18114>:
      ptr.162 = ptr;
      elem_size.167 = (sizetype) elem_size;
      D.24102 = ptr.162 + elem_size.167;
      if (D.24102 > end) goto <D.24099>; else goto <D.24103>;
      <D.24103>:
      elem_size.168 = (unsigned int) elem_size;
      D.24105 = ~elem_size.168;
      ptr.162 = ptr;
      ptr.169 = (unsigned int) ptr.162;
      if (D.24105 < ptr.169) goto <D.24099>; else goto <D.24100>;
      <D.24099>:
      D.24004 = ctx->report_error;
      if (D.24004 != 0) goto <D.24107>; else goto <D.24108>;
      <D.24107>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24109 = monoeg_strdup ("CustomAttribute: Not enough space for element");
        vinfo->info.message = D.24109;
        vinfo->exception_type = 3;
        D.24008 = ctx->errors;
        D.24110 = monoeg_g_slist_prepend (D.24008, vinfo);
        ctx->errors = D.24110;
      }
      <D.24108>:
      ctx->valid = 0;
      D.24000 = 0;
      return D.24000;
      <D.24100>:
      ptr.162 = ptr;
      elem_size.167 = (sizetype) elem_size;
      D.24102 = ptr.162 + elem_size.167;
      *_ptr = D.24102;
      D.24000 = 1;
      return D.24000;
    }
  finally
    {
      ptr = {CLOBBER};
      element_count = {CLOBBER};
    }
}


is_valid_cattr_type (struct MonoType * type)
{
  unsigned char D.24119;
  unsigned char D.24121;
  gboolean D.24122;
  int iftmp.170;
  unsigned int D.24129;
  unsigned int D.24130;
  struct MonoClass * D.24134;
  struct MonoClass * D.24135;
  _Bool D.24136;
  struct MonoClass * klass;

  D.24119 = type->type;
  if (D.24119 == 28) goto <D.24117>; else goto <D.24120>;
  <D.24120>:
  D.24119 = type->type;
  D.24121 = D.24119 + 254;
  if (D.24121 <= 12) goto <D.24117>; else goto <D.24118>;
  <D.24117>:
  D.24122 = 1;
  return D.24122;
  <D.24118>:
  D.24119 = type->type;
  if (D.24119 == 17) goto <D.24123>; else goto <D.24124>;
  <D.24123>:
  klass = mono_class_from_mono_type (type);
  if (klass != 0B) goto <D.24128>; else goto <D.24126>;
  <D.24128>:
  D.24129 = BIT_FIELD_REF <*klass, 32, 160>;
  D.24130 = D.24129 & 16;
  if (D.24130 != 0) goto <D.24131>; else goto <D.24126>;
  <D.24131>:
  iftmp.170 = 1;
  goto <D.24127>;
  <D.24126>:
  iftmp.170 = 0;
  <D.24127>:
  D.24122 = iftmp.170;
  return D.24122;
  <D.24124>:
  D.24119 = type->type;
  if (D.24119 == 18) goto <D.24132>; else goto <D.24133>;
  <D.24132>:
  D.24134 = mono_class_from_mono_type (type);
  D.24135 = mono_defaults.systemtype_class;
  D.24136 = D.24134 == D.24135;
  D.24122 = (gboolean) D.24136;
  return D.24122;
  <D.24133>:
  D.24122 = 0;
  return D.24122;
}


verify_field_marshal_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24138;
  unsigned int D.24139;
  int D.24140;
  int D.24143;
  gchar * D.24146;
  struct GSList * D.24147;
  struct GSList * D.24148;
  <unnamed-unsigned:24> D.24149;
  int D.24150;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.24138 = ctx->image;
      table = &D.24138->tables[13];
      i = 0;
      goto <D.18647>;
      <D.18646>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.24139 = data[1];
      D.24140 = is_valid_marshal_spec (ctx, D.24139);
      if (D.24140 == 0) goto <D.24141>; else goto <D.24142>;
      <D.24141>:
      D.24143 = ctx->report_error;
      if (D.24143 != 0) goto <D.24144>; else goto <D.24145>;
      <D.24144>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24139 = data[1];
        D.24146 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d NativeType field 0x%08x", i, D.24139);
        vinfo->info.message = D.24146;
        vinfo->exception_type = 3;
        D.24147 = ctx->errors;
        D.24148 = monoeg_g_slist_prepend (D.24147, vinfo);
        ctx->errors = D.24148;
      }
      <D.24145>:
      ctx->valid = 0;
      return;
      <D.24142>:
      i = i + 1;
      <D.18647>:
      D.24149 = table->rows;
      D.24150 = (int) D.24149;
      if (D.24150 > i) goto <D.18646>; else goto <D.18648>;
      <D.18648>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_marshal_spec (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.24154;
  struct MonoStreamHeader * D.24155;
  gboolean D.24156;
  int iftmp.171;
  unsigned int D.24160;
  unsigned int D.24162;
  struct OffsetAndSize blob;

  try
    {
      D.24154 = ctx->image;
      D.24155 = &D.24154->heap_blob;
      blob = get_metadata_stream (ctx, D.24155); [return slot optimization]
      D.24160 = blob.size;
      if (D.24160 != 0) goto <D.24161>; else goto <D.24158>;
      <D.24161>:
      D.24160 = blob.size;
      D.24162 = D.24160 + 4294967295;
      if (D.24162 >= offset) goto <D.24163>; else goto <D.24158>;
      <D.24163>:
      iftmp.171 = 1;
      goto <D.24159>;
      <D.24158>:
      iftmp.171 = 0;
      <D.24159>:
      D.24156 = iftmp.171;
      return D.24156;
    }
  finally
    {
      blob = {CLOBBER};
    }
}


verify_decl_security_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24166;
  unsigned int D.24167;
  int D.24168;
  int D.24171;
  gchar * D.24174;
  struct GSList * D.24175;
  struct GSList * D.24176;
  <unnamed-unsigned:24> D.24177;
  int D.24178;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.24166 = ctx->image;
      table = &D.24166->tables[14];
      i = 0;
      goto <D.18669>;
      <D.18668>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.24167 = data[2];
      D.24168 = is_valid_permission_set (ctx, D.24167);
      if (D.24168 == 0) goto <D.24169>; else goto <D.24170>;
      <D.24169>:
      D.24171 = ctx->report_error;
      if (D.24171 != 0) goto <D.24172>; else goto <D.24173>;
      <D.24172>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24167 = data[2];
        D.24174 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d PermissionSet field 0x%08x", i, D.24167);
        vinfo->info.message = D.24174;
        vinfo->exception_type = 3;
        D.24175 = ctx->errors;
        D.24176 = monoeg_g_slist_prepend (D.24175, vinfo);
        ctx->errors = D.24176;
      }
      <D.24173>:
      ctx->valid = 0;
      return;
      <D.24170>:
      i = i + 1;
      <D.18669>:
      D.24177 = table->rows;
      D.24178 = (int) D.24177;
      if (D.24178 > i) goto <D.18668>; else goto <D.18670>;
      <D.18670>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_permission_set (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.24182;
  struct MonoStreamHeader * D.24183;
  gboolean D.24184;
  int iftmp.172;
  unsigned int D.24188;
  unsigned int D.24190;
  struct OffsetAndSize blob;

  try
    {
      D.24182 = ctx->image;
      D.24183 = &D.24182->heap_blob;
      blob = get_metadata_stream (ctx, D.24183); [return slot optimization]
      D.24188 = blob.size;
      if (D.24188 != 0) goto <D.24189>; else goto <D.24186>;
      <D.24189>:
      D.24188 = blob.size;
      D.24190 = D.24188 + 4294967295;
      if (D.24190 >= offset) goto <D.24191>; else goto <D.24186>;
      <D.24191>:
      iftmp.172 = 1;
      goto <D.24187>;
      <D.24186>:
      iftmp.172 = 0;
      <D.24187>:
      D.24184 = iftmp.172;
      return D.24184;
    }
  finally
    {
      blob = {CLOBBER};
    }
}


verify_standalonesig_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24194;
  unsigned int D.24195;
  int D.24196;
  int D.24199;
  gchar * D.24202;
  struct GSList * D.24203;
  struct GSList * D.24204;
  <unnamed-unsigned:24> D.24205;
  int D.24206;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.24194 = ctx->image;
      table = &D.24194->tables[17];
      i = 0;
      goto <D.18721>;
      <D.18720>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.24195 = data[0];
      D.24196 = is_valid_standalonesig_blob (ctx, D.24195);
      if (D.24196 == 0) goto <D.24197>; else goto <D.24198>;
      <D.24197>:
      D.24199 = ctx->report_error;
      if (D.24199 != 0) goto <D.24200>; else goto <D.24201>;
      <D.24200>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24195 = data[0];
        D.24202 = monoeg_g_strdup_printf ("Invalid StandAloneSig row %d Signature field 0x%08x", i, D.24195);
        vinfo->info.message = D.24202;
        vinfo->exception_type = 3;
        D.24203 = ctx->errors;
        D.24204 = monoeg_g_slist_prepend (D.24203, vinfo);
        ctx->errors = D.24204;
      }
      <D.24201>:
      ctx->valid = 0;
      return;
      <D.24198>:
      i = i + 1;
      <D.18721>:
      D.24205 = table->rows;
      D.24206 = (int) D.24205;
      if (D.24206 > i) goto <D.18720>; else goto <D.18722>;
      <D.18722>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_standalonesig_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.24210;
  int D.24213;
  gchar * D.24216;
  struct GSList * D.24217;
  struct GSList * D.24218;
  gboolean D.24219;
  const char * ptr.173;
  unsigned int size.174;
  int D.24222;
  gchar * D.24227;
  struct GSList * D.24228;
  const char * ptr.175;
  unsigned int signature.176;
  guint32 size;
  unsigned int signature;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      signature = 0;
      ptr = 0B;
      D.24210 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.24210 == 0) goto <D.24211>; else goto <D.24212>;
      <D.24211>:
      D.24213 = ctx->report_error;
      if (D.24213 != 0) goto <D.24214>; else goto <D.24215>;
      <D.24214>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24216 = monoeg_strdup ("StandAloneSig: Could not decode signature header");
        vinfo->info.message = D.24216;
        vinfo->exception_type = 3;
        D.24217 = ctx->errors;
        D.24218 = monoeg_g_slist_prepend (D.24217, vinfo);
        ctx->errors = D.24218;
      }
      <D.24215>:
      ctx->valid = 0;
      D.24219 = 0;
      return D.24219;
      <D.24212>:
      ptr.173 = ptr;
      size.174 = size;
      end = ptr.173 + size.174;
      D.24222 = safe_read (&ptr, end, &signature, 1);
      if (D.24222 == 0) goto <D.24223>; else goto <D.24224>;
      <D.24223>:
      D.24213 = ctx->report_error;
      if (D.24213 != 0) goto <D.24225>; else goto <D.24226>;
      <D.24225>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24227 = monoeg_strdup ("StandAloneSig: Not enough room for the call conv");
        vinfo->info.message = D.24227;
        vinfo->exception_type = 3;
        D.24217 = ctx->errors;
        D.24228 = monoeg_g_slist_prepend (D.24217, vinfo);
        ctx->errors = D.24228;
      }
      <D.24226>:
      ctx->valid = 0;
      D.24219 = 0;
      return D.24219;
      <D.24224>:
      ptr.173 = ptr;
      ptr.175 = ptr.173 + 4294967295;
      ptr = ptr.175;
      signature.176 = signature;
      if (signature.176 == 7) goto <D.24231>; else goto <D.24232>;
      <D.24231>:
      D.24219 = parse_locals_signature (ctx, &ptr, end);
      return D.24219;
      <D.24232>:
      signature.176 = signature;
      if (signature.176 == 6) goto <D.24233>; else goto <D.24234>;
      <D.24233>:
      D.24219 = parse_field (ctx, &ptr, end);
      return D.24219;
      <D.24234>:
      D.24219 = parse_method_signature (ctx, &ptr, end, 1, 1);
      return D.24219;
    }
  finally
    {
      size = {CLOBBER};
      signature = {CLOBBER};
      ptr = {CLOBBER};
    }
}


parse_locals_signature (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.177;
  int D.24238;
  int D.24241;
  gchar * D.24244;
  struct GSList * D.24245;
  struct GSList * D.24246;
  gboolean D.24247;
  unsigned int sig.178;
  gchar * D.24253;
  struct GSList * D.24254;
  int D.24255;
  gchar * D.24260;
  struct GSList * D.24261;
  int D.24262;
  gchar * D.24267;
  struct GSList * D.24268;
  int D.24271;
  gchar * D.24276;
  struct GSList * D.24277;
  int D.24278;
  gchar * D.24283;
  struct GSList * D.24284;
  unsigned int D.24285;
  int D.24289;
  gchar * D.24294;
  struct GSList * D.24295;
  gchar * D.24300;
  struct GSList * D.24301;
  const char * ptr.179;
  const char * ptr.180;
  int D.24306;
  gchar * D.24311;
  struct GSList * D.24312;
  unsigned int locals_count.181;
  unsigned int sig;
  unsigned int locals_count;
  unsigned int i;
  const char * ptr;

  try
    {
      sig = 0;
      locals_count = 0;
      ptr.177 = *_ptr;
      ptr = ptr.177;
      D.24238 = safe_read (&ptr, end, &sig, 1);
      if (D.24238 == 0) goto <D.24239>; else goto <D.24240>;
      <D.24239>:
      D.24241 = ctx->report_error;
      if (D.24241 != 0) goto <D.24242>; else goto <D.24243>;
      <D.24242>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24244 = monoeg_strdup ("LocalsSig: Not enough room for signature");
        vinfo->info.message = D.24244;
        vinfo->exception_type = 3;
        D.24245 = ctx->errors;
        D.24246 = monoeg_g_slist_prepend (D.24245, vinfo);
        ctx->errors = D.24246;
      }
      <D.24243>:
      ctx->valid = 0;
      D.24247 = 0;
      return D.24247;
      <D.24240>:
      sig.178 = sig;
      if (sig.178 != 7) goto <D.24249>; else goto <D.24250>;
      <D.24249>:
      D.24241 = ctx->report_error;
      if (D.24241 != 0) goto <D.24251>; else goto <D.24252>;
      <D.24251>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        sig.178 = sig;
        D.24253 = monoeg_g_strdup_printf ("LocalsSig: Signature is not 0x28 or 0x08: %x", sig.178);
        vinfo->info.message = D.24253;
        vinfo->exception_type = 3;
        D.24245 = ctx->errors;
        D.24254 = monoeg_g_slist_prepend (D.24245, vinfo);
        ctx->errors = D.24254;
      }
      <D.24252>:
      ctx->valid = 0;
      D.24247 = 0;
      return D.24247;
      <D.24250>:
      D.24255 = safe_read_compressed_int (&ptr, end, &locals_count);
      if (D.24255 == 0) goto <D.24256>; else goto <D.24257>;
      <D.24256>:
      D.24241 = ctx->report_error;
      if (D.24241 != 0) goto <D.24258>; else goto <D.24259>;
      <D.24258>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24260 = monoeg_strdup ("LocalsSig: Not enough room for the param count");
        vinfo->info.message = D.24260;
        vinfo->exception_type = 3;
        D.24245 = ctx->errors;
        D.24261 = monoeg_g_slist_prepend (D.24245, vinfo);
        ctx->errors = D.24261;
      }
      <D.24259>:
      ctx->valid = 0;
      D.24247 = 0;
      return D.24247;
      <D.24257>:
      i = 0;
      goto <D.18011>;
      <D.18010>:
      D.24262 = safe_read (&ptr, end, &sig, 1);
      if (D.24262 == 0) goto <D.24263>; else goto <D.24264>;
      <D.24263>:
      D.24241 = ctx->report_error;
      if (D.24241 != 0) goto <D.24265>; else goto <D.24266>;
      <D.24265>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24267 = monoeg_strdup ("LocalsSig: Not enough room for type");
        vinfo->info.message = D.24267;
        vinfo->exception_type = 3;
        D.24245 = ctx->errors;
        D.24268 = monoeg_g_slist_prepend (D.24245, vinfo);
        ctx->errors = D.24268;
      }
      <D.24266>:
      ctx->valid = 0;
      D.24247 = 0;
      return D.24247;
      <D.24264>:
      goto <D.18004>;
      <D.18003>:
      sig.178 = sig;
      if (sig.178 != 69) goto <D.24269>; else goto <D.24270>;
      <D.24269>:
      D.24271 = parse_custom_mods (ctx, &ptr, end);
      if (D.24271 == 0) goto <D.24272>; else goto <D.24273>;
      <D.24272>:
      D.24241 = ctx->report_error;
      if (D.24241 != 0) goto <D.24274>; else goto <D.24275>;
      <D.24274>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24276 = monoeg_g_strdup_printf ("LocalsSig: Error parsing local %d", i);
        vinfo->info.message = D.24276;
        vinfo->exception_type = 3;
        D.24245 = ctx->errors;
        D.24277 = monoeg_g_slist_prepend (D.24245, vinfo);
        ctx->errors = D.24277;
      }
      <D.24275>:
      ctx->valid = 0;
      D.24247 = 0;
      return D.24247;
      <D.24273>:
      <D.24270>:
      D.24278 = safe_read (&ptr, end, &sig, 1);
      if (D.24278 == 0) goto <D.24279>; else goto <D.24280>;
      <D.24279>:
      D.24241 = ctx->report_error;
      if (D.24241 != 0) goto <D.24281>; else goto <D.24282>;
      <D.24281>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24283 = monoeg_strdup ("LocalsSig: Not enough room for type");
        vinfo->info.message = D.24283;
        vinfo->exception_type = 3;
        D.24245 = ctx->errors;
        D.24284 = monoeg_g_slist_prepend (D.24245, vinfo);
        ctx->errors = D.24284;
      }
      <D.24282>:
      ctx->valid = 0;
      D.24247 = 0;
      return D.24247;
      <D.24280>:
      <D.18004>:
      sig.178 = sig;
      D.24285 = sig.178 + 4294967265;
      if (D.24285 <= 1) goto <D.18003>; else goto <D.24286>;
      <D.24286>:
      sig.178 = sig;
      if (sig.178 == 69) goto <D.18003>; else goto <D.18005>;
      <D.18005>:
      sig.178 = sig;
      if (sig.178 == 16) goto <D.24287>; else goto <D.24288>;
      <D.24287>:
      D.24289 = safe_read (&ptr, end, &sig, 1);
      if (D.24289 == 0) goto <D.24290>; else goto <D.24291>;
      <D.24290>:
      D.24241 = ctx->report_error;
      if (D.24241 != 0) goto <D.24292>; else goto <D.24293>;
      <D.24292>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24294 = monoeg_g_strdup_printf ("Type: Not enough room for byref type for local %d", i);
        vinfo->info.message = D.24294;
        vinfo->exception_type = 3;
        D.24245 = ctx->errors;
        D.24295 = monoeg_g_slist_prepend (D.24245, vinfo);
        ctx->errors = D.24295;
      }
      <D.24293>:
      ctx->valid = 0;
      D.24247 = 0;
      return D.24247;
      <D.24291>:
      sig.178 = sig;
      if (sig.178 == 22) goto <D.24296>; else goto <D.24297>;
      <D.24296>:
      D.24241 = ctx->report_error;
      if (D.24241 != 0) goto <D.24298>; else goto <D.24299>;
      <D.24298>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24300 = monoeg_g_strdup_printf ("Type: Invalid type typedref& for local %d", i);
        vinfo->info.message = D.24300;
        vinfo->exception_type = 3;
        D.24245 = ctx->errors;
        D.24301 = monoeg_g_slist_prepend (D.24245, vinfo);
        ctx->errors = D.24301;
      }
      <D.24299>:
      ctx->valid = 0;
      D.24247 = 0;
      return D.24247;
      <D.24297>:
      <D.24288>:
      sig.178 = sig;
      if (sig.178 == 22) goto <D.24302>; else goto <D.24303>;
      <D.24302>:
      // predicted unlikely by continue predictor.
      goto <D.18008>;
      <D.24303>:
      ptr.179 = ptr;
      ptr.180 = ptr.179 + 4294967295;
      ptr = ptr.180;
      D.24306 = parse_type (ctx, &ptr, end);
      if (D.24306 == 0) goto <D.24307>; else goto <D.24308>;
      <D.24307>:
      D.24241 = ctx->report_error;
      if (D.24241 != 0) goto <D.24309>; else goto <D.24310>;
      <D.24309>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24311 = monoeg_g_strdup_printf ("LocalsSig: Error parsing local %d", i);
        vinfo->info.message = D.24311;
        vinfo->exception_type = 3;
        D.24245 = ctx->errors;
        D.24312 = monoeg_g_slist_prepend (D.24245, vinfo);
        ctx->errors = D.24312;
      }
      <D.24310>:
      ctx->valid = 0;
      D.24247 = 0;
      return D.24247;
      <D.24308>:
      <D.18008>:
      i = i + 1;
      <D.18011>:
      locals_count.181 = locals_count;
      if (i < locals_count.181) goto <D.18010>; else goto <D.18012>;
      <D.18012>:
      ptr.179 = ptr;
      *_ptr = ptr.179;
      D.24247 = 1;
      return D.24247;
    }
  finally
    {
      sig = {CLOBBER};
      locals_count = {CLOBBER};
      ptr = {CLOBBER};
    }
}


verify_event_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24316;
  unsigned int i.182;
  int D.24320;
  gchar * D.24323;
  struct GSList * D.24324;
  struct GSList * D.24325;
  int D.24326;
  unsigned int D.24327;
  unsigned int D.24329;
  unsigned int D.24331;
  unsigned int D.24332;
  unsigned int D.24335;
  <unnamed-unsigned:24> D.24341;
  int D.24342;
  gchar * D.24347;
  struct GSList * D.24348;
  gchar * D.24353;
  struct GSList * D.24354;
  <unnamed-unsigned:24> D.24355;
  int D.24356;
  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.24316 = ctx->image;
      table = &D.24316->tables[20];
      D.24316 = ctx->image;
      sema_table = &D.24316->tables[24];
      i = 0;
      goto <D.18769>;
      <D.18768>:
      mono_metadata_decode_row (table, i, &data, 3);
      i.182 = (unsigned int) i;
      token = make_coded_token (48, 20, i.182);
      idx = search_sorted_table (ctx, 24, 2, token);
      if (idx == -1) goto <D.24318>; else goto <D.24319>;
      <D.24318>:
      D.24320 = ctx->report_error;
      if (D.24320 != 0) goto <D.24321>; else goto <D.24322>;
      <D.24321>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24323 = monoeg_g_strdup_printf ("Invalid Event row %d has no AddOn or RemoveOn associated methods", i);
        vinfo->info.message = D.24323;
        vinfo->exception_type = 3;
        D.24324 = ctx->errors;
        D.24325 = monoeg_g_slist_prepend (D.24324, vinfo);
        ctx->errors = D.24325;
      }
      <D.24322>:
      ctx->valid = 0;
      return;
      <D.24319>:
      goto <D.18762>;
      <D.18761>:
      D.24326 = idx + -1;
      D.24327 = mono_metadata_decode_row_col (sema_table, D.24326, 2);
      if (D.24327 != token) goto <D.18760>; else goto <D.24328>;
      <D.24328>:
      idx = idx + -1;
      <D.18762>:
      if (idx > 0) goto <D.18761>; else goto <D.18760>;
      <D.18760>:
      found_remove = 0;
      found_add = found_remove;
      goto <D.18765>;
      <D.18764>:
      mono_metadata_decode_row (sema_table, idx, &sema_data, 3);
      D.24329 = sema_data[2];
      if (D.24329 != token) goto <D.18763>; else goto <D.24330>;
      <D.24330>:
      D.24331 = sema_data[0];
      D.24332 = D.24331 & 8;
      if (D.24332 != 0) goto <D.24333>; else goto <D.24334>;
      <D.24333>:
      found_add = 1;
      <D.24334>:
      D.24331 = sema_data[0];
      D.24335 = D.24331 & 16;
      if (D.24335 != 0) goto <D.24336>; else goto <D.24337>;
      <D.24336>:
      found_remove = 1;
      <D.24337>:
      if (found_add != 0) goto <D.24338>; else goto <D.24339>;
      <D.24338>:
      if (found_remove != 0) goto <D.18763>; else goto <D.24340>;
      <D.24340>:
      <D.24339>:
      idx = idx + 1;
      <D.18765>:
      D.24341 = sema_table->rows;
      D.24342 = (int) D.24341;
      if (D.24342 > idx) goto <D.18764>; else goto <D.18763>;
      <D.18763>:
      if (found_add == 0) goto <D.24343>; else goto <D.24344>;
      <D.24343>:
      D.24320 = ctx->report_error;
      if (D.24320 != 0) goto <D.24345>; else goto <D.24346>;
      <D.24345>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24347 = monoeg_g_strdup_printf ("Invalid Event row %d has no AddOn associated method", i);
        vinfo->info.message = D.24347;
        vinfo->exception_type = 3;
        D.24324 = ctx->errors;
        D.24348 = monoeg_g_slist_prepend (D.24324, vinfo);
        ctx->errors = D.24348;
      }
      <D.24346>:
      ctx->valid = 0;
      return;
      <D.24344>:
      if (found_remove == 0) goto <D.24349>; else goto <D.24350>;
      <D.24349>:
      D.24320 = ctx->report_error;
      if (D.24320 != 0) goto <D.24351>; else goto <D.24352>;
      <D.24351>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24353 = monoeg_g_strdup_printf ("Invalid Event row %d has no RemoveOn associated method", i);
        vinfo->info.message = D.24353;
        vinfo->exception_type = 3;
        D.24324 = ctx->errors;
        D.24354 = monoeg_g_slist_prepend (D.24324, vinfo);
        ctx->errors = D.24354;
      }
      <D.24352>:
      ctx->valid = 0;
      return;
      <D.24350>:
      i = i + 1;
      <D.18769>:
      D.24355 = table->rows;
      D.24356 = (int) D.24355;
      if (D.24356 > i) goto <D.18768>; else goto <D.18770>;
      <D.18770>:
    }
  finally
    {
      data = {CLOBBER};
      sema_data = {CLOBBER};
    }
}


verify_typespec_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24360;
  int D.24361;
  int D.24362;
  unsigned int D.24363;
  unsigned int D.24364;
  int D.24365;
  int D.24368;
  gchar * D.24371;
  struct GSList * D.24372;
  struct GSList * D.24373;
  <unnamed-unsigned:24> D.24374;
  int D.24375;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.24360 = ctx->image;
      table = &D.24360->tables[27];
      i = 0;
      goto <D.18838>;
      <D.18837>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.24361 = i + 1;
      D.24362 = D.24361 | 452984832;
      D.24363 = (unsigned int) D.24362;
      ctx->token = D.24363;
      D.24364 = data[0];
      D.24365 = is_valid_typespec_blob (ctx, D.24364);
      if (D.24365 == 0) goto <D.24366>; else goto <D.24367>;
      <D.24366>:
      D.24368 = ctx->report_error;
      if (D.24368 != 0) goto <D.24369>; else goto <D.24370>;
      <D.24369>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24364 = data[0];
        D.24371 = monoeg_g_strdup_printf ("Invalid TypeSpec row %d Signature field %08x", i, D.24364);
        vinfo->info.message = D.24371;
        vinfo->exception_type = 3;
        D.24372 = ctx->errors;
        D.24373 = monoeg_g_slist_prepend (D.24372, vinfo);
        ctx->errors = D.24373;
      }
      <D.24370>:
      ctx->valid = 0;
      return;
      <D.24367>:
      i = i + 1;
      <D.18838>:
      D.24374 = table->rows;
      D.24375 = (int) D.24374;
      if (D.24375 > i) goto <D.18837>; else goto <D.18839>;
      <D.18839>:
      ctx->token = 0;
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_typespec_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.24379;
  int D.24382;
  gchar * D.24385;
  struct GSList * D.24386;
  struct GSList * D.24387;
  gboolean D.24388;
  const char * ptr.183;
  unsigned int size.184;
  int D.24391;
  int D.24394;
  gchar * D.24399;
  struct GSList * D.24400;
  unsigned int type.185;
  int D.24404;
  gchar * D.24409;
  struct GSList * D.24410;
  gchar * D.24415;
  struct GSList * D.24416;
  const char * ptr.186;
  guint32 size;
  const char * ptr;
  const char * end;
  unsigned int type;

  try
    {
      size = 0;
      ptr = 0B;
      type = 0;
      D.24379 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.24379 == 0) goto <D.24380>; else goto <D.24381>;
      <D.24380>:
      D.24382 = ctx->report_error;
      if (D.24382 != 0) goto <D.24383>; else goto <D.24384>;
      <D.24383>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24385 = monoeg_strdup ("TypeSpec: Could not decode signature header");
        vinfo->info.message = D.24385;
        vinfo->exception_type = 3;
        D.24386 = ctx->errors;
        D.24387 = monoeg_g_slist_prepend (D.24386, vinfo);
        ctx->errors = D.24387;
      }
      <D.24384>:
      ctx->valid = 0;
      D.24388 = 0;
      return D.24388;
      <D.24381>:
      ptr.183 = ptr;
      size.184 = size;
      end = ptr.183 + size.184;
      D.24391 = parse_custom_mods (ctx, &ptr, end);
      if (D.24391 == 0) goto <D.24392>; else goto <D.24393>;
      <D.24392>:
      D.24388 = 0;
      return D.24388;
      <D.24393>:
      D.24394 = safe_read (&ptr, end, &type, 1);
      if (D.24394 == 0) goto <D.24395>; else goto <D.24396>;
      <D.24395>:
      D.24382 = ctx->report_error;
      if (D.24382 != 0) goto <D.24397>; else goto <D.24398>;
      <D.24397>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24399 = monoeg_strdup ("TypeSpec: Not enough room for type");
        vinfo->info.message = D.24399;
        vinfo->exception_type = 3;
        D.24386 = ctx->errors;
        D.24400 = monoeg_g_slist_prepend (D.24386, vinfo);
        ctx->errors = D.24400;
      }
      <D.24398>:
      ctx->valid = 0;
      D.24388 = 0;
      return D.24388;
      <D.24396>:
      type.185 = type;
      if (type.185 == 16) goto <D.24402>; else goto <D.24403>;
      <D.24402>:
      D.24404 = safe_read (&ptr, end, &type, 1);
      if (D.24404 == 0) goto <D.24405>; else goto <D.24406>;
      <D.24405>:
      D.24382 = ctx->report_error;
      if (D.24382 != 0) goto <D.24407>; else goto <D.24408>;
      <D.24407>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24409 = monoeg_strdup ("TypeSpec: Not enough room for byref type");
        vinfo->info.message = D.24409;
        vinfo->exception_type = 3;
        D.24386 = ctx->errors;
        D.24410 = monoeg_g_slist_prepend (D.24386, vinfo);
        ctx->errors = D.24410;
      }
      <D.24408>:
      ctx->valid = 0;
      D.24388 = 0;
      return D.24388;
      <D.24406>:
      type.185 = type;
      if (type.185 == 22) goto <D.24411>; else goto <D.24412>;
      <D.24411>:
      D.24382 = ctx->report_error;
      if (D.24382 != 0) goto <D.24413>; else goto <D.24414>;
      <D.24413>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24415 = monoeg_strdup ("TypeSpec: Invalid type typedref&");
        vinfo->info.message = D.24415;
        vinfo->exception_type = 3;
        D.24386 = ctx->errors;
        D.24416 = monoeg_g_slist_prepend (D.24386, vinfo);
        ctx->errors = D.24416;
      }
      <D.24414>:
      ctx->valid = 0;
      D.24388 = 0;
      return D.24388;
      <D.24412>:
      <D.24403>:
      type.185 = type;
      if (type.185 == 22) goto <D.24417>; else goto <D.24418>;
      <D.24417>:
      D.24388 = 1;
      return D.24388;
      <D.24418>:
      ptr.183 = ptr;
      ptr.186 = ptr.183 + 4294967295;
      ptr = ptr.186;
      D.24388 = parse_type (ctx, &ptr, end);
      return D.24388;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
      type = {CLOBBER};
    }
}


verify_method_spec_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24422;
  unsigned int D.24423;
  int D.24424;
  int D.24427;
  gchar * D.24430;
  struct GSList * D.24431;
  struct GSList * D.24432;
  <unnamed-unsigned:24> D.24433;
  int D.24434;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.24422 = ctx->image;
      table = &D.24422->tables[43];
      i = 0;
      goto <D.18996>;
      <D.18995>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.24423 = data[1];
      D.24424 = is_valid_methodspec_blob (ctx, D.24423);
      if (D.24424 == 0) goto <D.24425>; else goto <D.24426>;
      <D.24425>:
      D.24427 = ctx->report_error;
      if (D.24427 != 0) goto <D.24428>; else goto <D.24429>;
      <D.24428>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24423 = data[1];
        D.24430 = monoeg_g_strdup_printf ("MethodSpec table row %d has invalid Instantiation token %08x", i, D.24423);
        vinfo->info.message = D.24430;
        vinfo->exception_type = 3;
        D.24431 = ctx->errors;
        D.24432 = monoeg_g_slist_prepend (D.24431, vinfo);
        ctx->errors = D.24432;
      }
      <D.24429>:
      ctx->valid = 0;
      return;
      <D.24426>:
      i = i + 1;
      <D.18996>:
      D.24433 = table->rows;
      D.24434 = (int) D.24433;
      if (D.24434 > i) goto <D.18995>; else goto <D.18997>;
      <D.18997>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_methodspec_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.24438;
  int D.24441;
  gchar * D.24444;
  struct GSList * D.24445;
  struct GSList * D.24446;
  gboolean D.24447;
  const char * ptr.187;
  unsigned int size.188;
  int D.24450;
  gchar * D.24455;
  struct GSList * D.24456;
  unsigned int type.189;
  gchar * D.24462;
  struct GSList * D.24463;
  int D.24464;
  gchar * D.24469;
  struct GSList * D.24470;
  unsigned int count.190;
  gchar * D.24476;
  struct GSList * D.24477;
  int D.24478;
  int D.24481;
  unsigned int D.24486;
  gchar * D.24487;
  struct GSList * D.24488;
  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.24438 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.24438 == 0) goto <D.24439>; else goto <D.24440>;
      <D.24439>:
      D.24441 = ctx->report_error;
      if (D.24441 != 0) goto <D.24442>; else goto <D.24443>;
      <D.24442>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24444 = monoeg_strdup ("MethodSpec: Could not decode signature header");
        vinfo->info.message = D.24444;
        vinfo->exception_type = 3;
        D.24445 = ctx->errors;
        D.24446 = monoeg_g_slist_prepend (D.24445, vinfo);
        ctx->errors = D.24446;
      }
      <D.24443>:
      ctx->valid = 0;
      D.24447 = 0;
      return D.24447;
      <D.24440>:
      ptr.187 = ptr;
      size.188 = size;
      end = ptr.187 + size.188;
      D.24450 = safe_read (&ptr, end, &type, 1);
      if (D.24450 == 0) goto <D.24451>; else goto <D.24452>;
      <D.24451>:
      D.24441 = ctx->report_error;
      if (D.24441 != 0) goto <D.24453>; else goto <D.24454>;
      <D.24453>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24455 = monoeg_strdup ("MethodSpec: Not enough room for call convention");
        vinfo->info.message = D.24455;
        vinfo->exception_type = 3;
        D.24445 = ctx->errors;
        D.24456 = monoeg_g_slist_prepend (D.24445, vinfo);
        ctx->errors = D.24456;
      }
      <D.24454>:
      ctx->valid = 0;
      D.24447 = 0;
      return D.24447;
      <D.24452>:
      type.189 = type;
      if (type.189 != 10) goto <D.24458>; else goto <D.24459>;
      <D.24458>:
      D.24441 = ctx->report_error;
      if (D.24441 != 0) goto <D.24460>; else goto <D.24461>;
      <D.24460>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        type.189 = type;
        D.24462 = monoeg_g_strdup_printf ("MethodSpec: Invalid call convention 0x%x, expected 0x0A", type.189);
        vinfo->info.message = D.24462;
        vinfo->exception_type = 3;
        D.24445 = ctx->errors;
        D.24463 = monoeg_g_slist_prepend (D.24445, vinfo);
        ctx->errors = D.24463;
      }
      <D.24461>:
      ctx->valid = 0;
      D.24447 = 0;
      return D.24447;
      <D.24459>:
      D.24464 = safe_read_compressed_int (&ptr, end, &count);
      if (D.24464 == 0) goto <D.24465>; else goto <D.24466>;
      <D.24465>:
      D.24441 = ctx->report_error;
      if (D.24441 != 0) goto <D.24467>; else goto <D.24468>;
      <D.24467>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24469 = monoeg_strdup ("MethodSpec: Not enough room for parameter count");
        vinfo->info.message = D.24469;
        vinfo->exception_type = 3;
        D.24445 = ctx->errors;
        D.24470 = monoeg_g_slist_prepend (D.24445, vinfo);
        ctx->errors = D.24470;
      }
      <D.24468>:
      ctx->valid = 0;
      D.24447 = 0;
      return D.24447;
      <D.24466>:
      count.190 = count;
      if (count.190 == 0) goto <D.24472>; else goto <D.24473>;
      <D.24472>:
      D.24441 = ctx->report_error;
      if (D.24441 != 0) goto <D.24474>; else goto <D.24475>;
      <D.24474>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24476 = monoeg_strdup ("MethodSpec: Zero generic argument count");
        vinfo->info.message = D.24476;
        vinfo->exception_type = 3;
        D.24445 = ctx->errors;
        D.24477 = monoeg_g_slist_prepend (D.24445, vinfo);
        ctx->errors = D.24477;
      }
      <D.24475>:
      ctx->valid = 0;
      D.24447 = 0;
      return D.24447;
      <D.24473>:
      i = 0;
      goto <D.18241>;
      <D.18240>:
      D.24478 = parse_custom_mods (ctx, &ptr, end);
      if (D.24478 == 0) goto <D.24479>; else goto <D.24480>;
      <D.24479>:
      D.24447 = 0;
      return D.24447;
      <D.24480>:
      D.24481 = parse_type (ctx, &ptr, end);
      if (D.24481 == 0) goto <D.24482>; else goto <D.24483>;
      <D.24482>:
      D.24441 = ctx->report_error;
      if (D.24441 != 0) goto <D.24484>; else goto <D.24485>;
      <D.24484>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24486 = i + 1;
        D.24487 = monoeg_g_strdup_printf ("MethodSpec: Could not parse parameter %d", D.24486);
        vinfo->info.message = D.24487;
        vinfo->exception_type = 3;
        D.24445 = ctx->errors;
        D.24488 = monoeg_g_slist_prepend (D.24445, vinfo);
        ctx->errors = D.24488;
      }
      <D.24485>:
      ctx->valid = 0;
      D.24447 = 0;
      return D.24447;
      <D.24483>:
      i = i + 1;
      <D.18241>:
      count.190 = count;
      if (i < count.190) goto <D.18240>; else goto <D.18242>;
      <D.18242>:
      D.24447 = 1;
      return D.24447;
    }
  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.24491;
  <unnamed-unsigned:24> D.24492;
  unsigned int D.24493;
  struct MonoTableInfo * table;
  struct MonoError error;
  guint32 i;

  try
    {
      D.24491 = ctx->image;
      table = &D.24491->tables[1];
      i = 0;
      goto <D.18350>;
      <D.18349>:
      D.24491 = ctx->image;
      mono_verifier_verify_typeref_row (D.24491, i, &error);
      add_from_mono_error (ctx, &error);
      i = i + 1;
      <D.18350>:
      D.24492 = table->rows;
      D.24493 = (unsigned int) D.24492;
      if (D.24493 > i) goto <D.18349>; else goto <D.18351>;
      <D.18351>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


add_from_mono_error (struct VerifyContext * ctx, struct MonoError * error)
{
  int D.24494;
  int D.24497;
  const char * D.24500;
  gchar * D.24501;
  struct GSList * D.24502;
  struct GSList * D.24503;

  D.24494 = mono_error_ok (error);
  if (D.24494 != 0) goto <D.24495>; else goto <D.24496>;
  <D.24495>:
  return;
  <D.24496>:
  D.24497 = ctx->report_error;
  if (D.24497 != 0) goto <D.24498>; else goto <D.24499>;
  <D.24498>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.24500 = mono_error_get_message (error);
    D.24501 = monoeg_strdup (D.24500);
    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.24499>:
  ctx->valid = 0;
  return;
  mono_error_cleanup (error);
}


verify_typeref_table_global_constraints (struct VerifyContext * ctx)
{
  struct MonoImage * D.24505;
  unsigned int D.24506;
  unsigned int D.24507;
  const char * D.24508;
  unsigned int D.24509;
  const char * D.24510;
  void * D.24511;
  int D.24514;
  const char * D.24517;
  const char * D.24518;
  unsigned int D.24519;
  gchar * D.24520;
  struct GSList * D.24521;
  struct GSList * D.24522;
  <unnamed-unsigned:24> D.24523;
  int D.24524;
  int i;
  guint32 data[3];
  struct MonoTableInfo * table;
  struct GHashTable * unique_types;

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

        type = monoeg_malloc (12);
        mono_metadata_decode_row (table, i, &data, 3);
        D.24506 = data[0];
        type->resolution_scope = D.24506;
        D.24505 = ctx->image;
        D.24507 = data[1];
        D.24508 = mono_metadata_string_heap (D.24505, D.24507);
        type->name = D.24508;
        D.24505 = ctx->image;
        D.24509 = data[2];
        D.24510 = mono_metadata_string_heap (D.24505, D.24509);
        type->name_space = D.24510;
        D.24511 = monoeg_g_hash_table_lookup (unique_types, type);
        if (D.24511 != 0B) goto <D.24512>; else goto <D.24513>;
        <D.24512>:
        D.24514 = ctx->report_error;
        if (D.24514 != 0) goto <D.24515>; else goto <D.24516>;
        <D.24515>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.24517 = type->name;
          D.24518 = type->name_space;
          D.24519 = type->resolution_scope;
          D.24520 = monoeg_g_strdup_printf ("TypeRef table row %d has duplicate for tuple (%s,%s,%x)", i, D.24517, D.24518, D.24519);
          vinfo->info.message = D.24520;
          vinfo->exception_type = 3;
          D.24521 = ctx->errors;
          D.24522 = monoeg_g_slist_prepend (D.24521, vinfo);
          ctx->errors = D.24522;
        }
        <D.24516>:
        ctx->valid = 0;
        monoeg_g_hash_table_destroy (unique_types);
        monoeg_g_free (type);
        return;
        <D.24513>:
        monoeg_g_hash_table_insert_replace (unique_types, type, 1B, 0);
      }
      i = i + 1;
      <D.19073>:
      D.24523 = table->rows;
      D.24524 = (int) D.24523;
      if (D.24524 > i) goto <D.19072>; else goto <D.19074>;
      <D.19074>:
      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.24528;
  gboolean D.24531;
  _Bool D.24532;
  int D.24533;
  struct VerifyContext ctx;

  try
    {
      D.24528 = mono_verifier_is_enabled_for_image (image);
      if (D.24528 == 0) goto <D.24529>; else goto <D.24530>;
      <D.24529>:
      D.24531 = 1;
      return D.24531;
      <D.24530>:
      D.24532 = error_list != 0B;
      D.24533 = (int) D.24532;
      init_verify_context (&ctx, image, D.24533);
      ctx.stage = 2;
      is_valid_field_signature (&ctx, offset);
      D.24531 = cleanup_context (&ctx, error_list);
      return D.24531;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_method_header (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.24536;
  gboolean D.24539;
  _Bool D.24540;
  int D.24541;
  unsigned int locals_token.191;
  struct MonoTableInfo * D.24545;
  unsigned int D.24546;
  int D.24547;
  struct VerifyContext ctx;
  guint32 locals_token;

  try
    {
      D.24536 = mono_verifier_is_enabled_for_image (image);
      if (D.24536 == 0) goto <D.24537>; else goto <D.24538>;
      <D.24537>:
      D.24539 = 1;
      return D.24539;
      <D.24538>:
      D.24540 = error_list != 0B;
      D.24541 = (int) D.24540;
      init_verify_context (&ctx, image, D.24541);
      ctx.stage = 2;
      is_valid_method_header (&ctx, offset, &locals_token);
      locals_token.191 = locals_token;
      if (locals_token.191 != 0) goto <D.24543>; else goto <D.24544>;
      <D.24543>:
      {
        guint32 sig_offset;

        D.24545 = &image->tables[17];
        locals_token.191 = locals_token;
        D.24546 = locals_token.191 + 4294967295;
        D.24547 = (int) D.24546;
        sig_offset = mono_metadata_decode_row_col (D.24545, D.24547, 0);
        is_valid_standalonesig_blob (&ctx, sig_offset);
      }
      <D.24544>:
      D.24539 = cleanup_context (&ctx, error_list);
      return D.24539;
    }
  finally
    {
      ctx = {CLOBBER};
      locals_token = {CLOBBER};
    }
}


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

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


cleanup_context_checked (struct VerifyContext * ctx, struct MonoError * error)
{
  struct SectionHeader * D.24556;
  struct GSList * D.24557;
  struct MonoImage * D.24560;
  char * D.24561;
  gboolean D.24562;

  D.24556 = ctx->sections;
  monoeg_g_free (D.24556);
  D.24557 = ctx->errors;
  if (D.24557 != 0B) goto <D.24558>; else goto <D.24559>;
  <D.24558>:
  {
    struct MonoVerifyInfo * info;

    D.24557 = ctx->errors;
    info = D.24557->data;
    D.24560 = ctx->image;
    D.24561 = info->message;
    mono_error_set_bad_image (error, D.24560, "%s", D.24561);
    D.24557 = ctx->errors;
    mono_free_verify_list (D.24557);
  }
  <D.24559>:
  D.24562 = ctx->valid;
  return D.24562;
}


mono_verifier_verify_memberref_method_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.24564;
  gboolean D.24567;
  _Bool D.24568;
  int D.24569;
  struct VerifyContext ctx;

  try
    {
      D.24564 = mono_verifier_is_enabled_for_image (image);
      if (D.24564 == 0) goto <D.24565>; else goto <D.24566>;
      <D.24565>:
      D.24567 = 1;
      return D.24567;
      <D.24566>:
      D.24568 = error_list != 0B;
      D.24569 = (int) D.24568;
      init_verify_context (&ctx, image, D.24569);
      ctx.stage = 2;
      is_valid_memberref_method_signature (&ctx, offset);
      D.24567 = cleanup_context (&ctx, error_list);
      return D.24567;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


is_valid_memberref_method_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.24572;
  int D.24575;
  gchar * D.24578;
  struct GSList * D.24579;
  struct GSList * D.24580;
  gboolean D.24581;
  const char * ptr.192;
  unsigned int size.193;
  guint32 size;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      ptr = 0B;
      D.24572 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.24572 == 0) goto <D.24573>; else goto <D.24574>;
      <D.24573>:
      D.24575 = ctx->report_error;
      if (D.24575 != 0) goto <D.24576>; else goto <D.24577>;
      <D.24576>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24578 = monoeg_strdup ("MemberRefSig: Could not decode signature header");
        vinfo->info.message = D.24578;
        vinfo->exception_type = 3;
        D.24579 = ctx->errors;
        D.24580 = monoeg_g_slist_prepend (D.24579, vinfo);
        ctx->errors = D.24580;
      }
      <D.24577>:
      ctx->valid = 0;
      D.24581 = 0;
      return D.24581;
      <D.24574>:
      ptr.192 = ptr;
      size.193 = size;
      end = ptr.192 + size.193;
      D.24581 = parse_method_signature (ctx, &ptr, end, 1, 0);
      return D.24581;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


mono_verifier_verify_memberref_field_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.24586;
  gboolean D.24589;
  _Bool D.24590;
  int D.24591;
  struct VerifyContext ctx;

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


mono_verifier_verify_standalone_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.24594;
  gboolean D.24597;
  _Bool D.24598;
  int D.24599;
  struct VerifyContext ctx;

  try
    {
      D.24594 = mono_verifier_is_enabled_for_image (image);
      if (D.24594 == 0) goto <D.24595>; else goto <D.24596>;
      <D.24595>:
      D.24597 = 1;
      return D.24597;
      <D.24596>:
      D.24598 = error_list != 0B;
      D.24599 = (int) D.24598;
      init_verify_context (&ctx, image, D.24599);
      ctx.stage = 2;
      is_valid_standalonesig_blob (&ctx, offset);
      D.24597 = cleanup_context (&ctx, error_list);
      return D.24597;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_typespec_signature (struct MonoImage * image, guint32 offset, guint32 token, struct GSList * * error_list)
{
  int D.24602;
  gboolean D.24605;
  _Bool D.24606;
  int D.24607;
  struct VerifyContext ctx;

  try
    {
      D.24602 = mono_verifier_is_enabled_for_image (image);
      if (D.24602 == 0) goto <D.24603>; else goto <D.24604>;
      <D.24603>:
      D.24605 = 1;
      return D.24605;
      <D.24604>:
      D.24606 = error_list != 0B;
      D.24607 = (int) D.24606;
      init_verify_context (&ctx, image, D.24607);
      ctx.stage = 2;
      ctx.token = token;
      is_valid_typespec_blob (&ctx, offset);
      D.24605 = cleanup_context (&ctx, error_list);
      return D.24605;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_methodspec_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.24610;
  gboolean D.24613;
  _Bool D.24614;
  int D.24615;
  struct VerifyContext ctx;

  try
    {
      D.24610 = mono_verifier_is_enabled_for_image (image);
      if (D.24610 == 0) goto <D.24611>; else goto <D.24612>;
      <D.24611>:
      D.24613 = 1;
      return D.24613;
      <D.24612>:
      D.24614 = error_list != 0B;
      D.24615 = (int) D.24614;
      init_verify_context (&ctx, image, D.24615);
      ctx.stage = 2;
      is_valid_methodspec_blob (&ctx, offset);
      D.24613 = cleanup_context (&ctx, error_list);
      return D.24613;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_string_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.24618;
  gboolean D.24621;
  _Bool D.24622;
  int D.24623;
  struct VerifyContext ctx;

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


verify_user_string (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.24626;
  struct MonoStreamHeader * D.24627;
  unsigned int D.24628;
  int D.24631;
  gchar * D.24634;
  struct GSList * D.24635;
  struct GSList * D.24636;
  const char * D.24637;
  unsigned int D.24638;
  sizetype D.24639;
  const char * D.24640;
  unsigned int D.24641;
  int D.24642;
  gchar * D.24647;
  struct GSList * D.24648;
  unsigned int bytes.194;
  unsigned int D.24650;
  unsigned int entry_size.195;
  gchar * D.24656;
  struct GSList * D.24657;
  unsigned int entry_size.196;
  unsigned int D.24661;
  unsigned int D.24663;
  gchar * D.24666;
  struct GSList * D.24667;
  struct OffsetAndSize heap_us;
  guint32 entry_size;
  guint32 bytes;

  try
    {
      D.24626 = ctx->image;
      D.24627 = &D.24626->heap_us;
      heap_us = get_metadata_stream (ctx, D.24627); [return slot optimization]
      D.24628 = heap_us.size;
      if (D.24628 < offset) goto <D.24629>; else goto <D.24630>;
      <D.24629>:
      D.24631 = ctx->report_error;
      if (D.24631 != 0) goto <D.24632>; else goto <D.24633>;
      <D.24632>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24634 = monoeg_strdup ("User string offset beyond heap_us size");
        vinfo->info.message = D.24634;
        vinfo->exception_type = 3;
        D.24635 = ctx->errors;
        D.24636 = monoeg_g_slist_prepend (D.24635, vinfo);
        ctx->errors = D.24636;
      }
      <D.24633>:
      ctx->valid = 0;
      return;
      <D.24630>:
      D.24637 = ctx->data;
      D.24638 = heap_us.offset;
      D.24639 = D.24638 + offset;
      D.24640 = D.24637 + D.24639;
      D.24628 = heap_us.size;
      D.24638 = heap_us.offset;
      D.24641 = D.24628 - D.24638;
      D.24642 = decode_value (D.24640, D.24641, &entry_size, &bytes);
      if (D.24642 == 0) goto <D.24643>; else goto <D.24644>;
      <D.24643>:
      D.24631 = ctx->report_error;
      if (D.24631 != 0) goto <D.24645>; else goto <D.24646>;
      <D.24645>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24647 = monoeg_strdup ("Could not decode user string blob size");
        vinfo->info.message = D.24647;
        vinfo->exception_type = 3;
        D.24635 = ctx->errors;
        D.24648 = monoeg_g_slist_prepend (D.24635, vinfo);
        ctx->errors = D.24648;
      }
      <D.24646>:
      ctx->valid = 0;
      return;
      <D.24644>:
      bytes.194 = bytes;
      D.24650 = ~bytes.194;
      entry_size.195 = entry_size;
      if (D.24650 < entry_size.195) goto <D.24652>; else goto <D.24653>;
      <D.24652>:
      D.24631 = ctx->report_error;
      if (D.24631 != 0) goto <D.24654>; else goto <D.24655>;
      <D.24654>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24656 = monoeg_strdup ("User string size overflow");
        vinfo->info.message = D.24656;
        vinfo->exception_type = 3;
        D.24635 = ctx->errors;
        D.24657 = monoeg_g_slist_prepend (D.24635, vinfo);
        ctx->errors = D.24657;
      }
      <D.24655>:
      ctx->valid = 0;
      return;
      <D.24653>:
      entry_size.195 = entry_size;
      bytes.194 = bytes;
      entry_size.196 = entry_size.195 + bytes.194;
      entry_size = entry_size.196;
      entry_size.195 = entry_size;
      D.24661 = offset + entry_size.195;
      D.24628 = heap_us.size;
      if (D.24661 > D.24628) goto <D.24659>; else goto <D.24662>;
      <D.24662>:
      entry_size.195 = entry_size;
      D.24663 = ~entry_size.195;
      if (D.24663 < offset) goto <D.24659>; else goto <D.24660>;
      <D.24659>:
      D.24631 = ctx->report_error;
      if (D.24631 != 0) goto <D.24664>; else goto <D.24665>;
      <D.24664>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24666 = monoeg_strdup ("User string oveflow heap_us");
        vinfo->info.message = D.24666;
        vinfo->exception_type = 3;
        D.24635 = ctx->errors;
        D.24667 = monoeg_g_slist_prepend (D.24635, vinfo);
        ctx->errors = D.24667;
      }
      <D.24665>:
      ctx->valid = 0;
      return;
      <D.24660>:
    }
  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.24671;
  gboolean D.24674;
  _Bool D.24675;
  int D.24676;
  struct VerifyContext ctx;

  try
    {
      D.24671 = mono_verifier_is_enabled_for_image (image);
      if (D.24671 == 0) goto <D.24672>; else goto <D.24673>;
      <D.24672>:
      D.24674 = 1;
      return D.24674;
      <D.24673>:
      D.24675 = error_list != 0B;
      D.24676 = (int) D.24675;
      init_verify_context (&ctx, image, D.24676);
      ctx.stage = 2;
      is_valid_cattr_blob (&ctx, offset);
      D.24674 = cleanup_context (&ctx, error_list);
      return D.24674;
    }
  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.24679;
  gboolean D.24682;
  _Bool D.24683;
  int D.24684;
  struct VerifyContext ctx;

  try
    {
      D.24679 = mono_verifier_is_enabled_for_image (image);
      if (D.24679 == 0) goto <D.24680>; else goto <D.24681>;
      <D.24680>:
      D.24682 = 1;
      return D.24682;
      <D.24681>:
      D.24683 = error_list != 0B;
      D.24684 = (int) D.24683;
      init_verify_context (&ctx, image, D.24684);
      ctx.stage = 2;
      is_valid_cattr_content (&ctx, ctor, data, size);
      D.24682 = cleanup_context (&ctx, error_list);
      return D.24682;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_is_sig_compatible (struct MonoImage * image, struct MonoMethod * method, struct MonoMethodSignature * signature)
{
  int D.24687;
  gboolean D.24690;
  unsigned int D.24691;
  unsigned int D.24692;
  unsigned int D.24695;
  unsigned int D.24696;
  unsigned int D.24697;
  unsigned int D.24700;
  unsigned int D.24703;
  unsigned int D.24708;
  short int D.24711;
  short int D.24712;
  int D.24716;
  struct MonoMethodSignature * original_sig;

  D.24687 = mono_verifier_is_enabled_for_image (image);
  if (D.24687 == 0) goto <D.24688>; else goto <D.24689>;
  <D.24688>:
  D.24690 = 1;
  return D.24690;
  <D.24689>:
  original_sig = mono_method_signature (method);
  D.24691 = BIT_FIELD_REF <*original_sig, 32, 64>;
  D.24692 = D.24691 & 4128768;
  if (D.24692 == 327680) goto <D.24693>; else goto <D.24694>;
  <D.24693>:
  D.24691 = BIT_FIELD_REF <*original_sig, 32, 64>;
  D.24695 = BIT_FIELD_REF <*signature, 32, 64>;
  D.24696 = D.24691 ^ D.24695;
  D.24697 = D.24696 & 4194304;
  if (D.24697 != 0) goto <D.24698>; else goto <D.24699>;
  <D.24698>:
  D.24690 = 0;
  return D.24690;
  <D.24699>:
  D.24691 = BIT_FIELD_REF <*original_sig, 32, 64>;
  D.24695 = BIT_FIELD_REF <*signature, 32, 64>;
  D.24696 = D.24691 ^ D.24695;
  D.24700 = D.24696 & 4128768;
  if (D.24700 != 0) goto <D.24701>; else goto <D.24702>;
  <D.24701>:
  D.24690 = 0;
  return D.24690;
  <D.24702>:
  D.24691 = BIT_FIELD_REF <*original_sig, 32, 64>;
  D.24695 = BIT_FIELD_REF <*signature, 32, 64>;
  D.24696 = D.24691 ^ D.24695;
  D.24703 = D.24696 & 8388608;
  if (D.24703 != 0) goto <D.24704>; else goto <D.24705>;
  <D.24704>:
  D.24690 = 0;
  return D.24690;
  <D.24705>:
  D.24691 = BIT_FIELD_REF <*original_sig, 32, 64>;
  D.24695 = BIT_FIELD_REF <*signature, 32, 64>;
  D.24696 = D.24691 ^ D.24695;
  D.24700 = D.24696 & 4128768;
  if (D.24700 != 0) goto <D.24706>; else goto <D.24707>;
  <D.24706>:
  D.24690 = 0;
  return D.24690;
  <D.24707>:
  D.24691 = BIT_FIELD_REF <*original_sig, 32, 64>;
  D.24695 = BIT_FIELD_REF <*signature, 32, 64>;
  D.24696 = D.24691 ^ D.24695;
  D.24708 = D.24696 & 16777216;
  if (D.24708 != 0) goto <D.24709>; else goto <D.24710>;
  <D.24709>:
  D.24690 = 0;
  return D.24690;
  <D.24710>:
  D.24711 = original_sig->sentinelpos;
  D.24712 = signature->sentinelpos;
  if (D.24711 != D.24712) goto <D.24713>; else goto <D.24714>;
  <D.24713>:
  D.24690 = 0;
  return D.24690;
  <D.24714>:
  goto <D.24715>;
  <D.24694>:
  D.24716 = mono_metadata_signature_equal (signature, original_sig);
  if (D.24716 == 0) goto <D.24717>; else goto <D.24718>;
  <D.24717>:
  D.24690 = 0;
  return D.24690;
  <D.24718>:
  <D.24715>:
  D.24690 = 1;
  return D.24690;
}


mono_verifier_verify_typeref_row (struct MonoImage * image, guint32 row, struct MonoError * error)
{
  int D.24720;
  gboolean D.24723;
  <unnamed-unsigned:24> D.24724;
  unsigned int D.24725;
  int D.24728;
  int row.197;
  unsigned int D.24730;
  int D.24731;
  unsigned int D.24734;
  unsigned int D.24739;
  int D.24741;
  unsigned int D.24742;
  int D.24745;
  struct MonoTableInfo * table;
  guint32 data[3];

  try
    {
      table = &image->tables[1];
      mono_error_init (error);
      D.24720 = mono_verifier_is_enabled_for_image (image);
      if (D.24720 == 0) goto <D.24721>; else goto <D.24722>;
      <D.24721>:
      D.24723 = 1;
      return D.24723;
      <D.24722>:
      D.24724 = table->rows;
      D.24725 = (unsigned int) D.24724;
      if (D.24725 <= row) goto <D.24726>; else goto <D.24727>;
      <D.24726>:
      D.24724 = table->rows;
      D.24728 = (int) D.24724;
      mono_error_set_bad_image (error, image, "Invalid typeref row %d - table has %d rows", row, D.24728);
      D.24723 = 0;
      return D.24723;
      <D.24727>:
      row.197 = (int) row;
      mono_metadata_decode_row (table, row.197, &data, 3);
      D.24730 = data[0];
      D.24731 = is_valid_coded_index_with_image (image, 72, D.24730);
      if (D.24731 == 0) goto <D.24732>; else goto <D.24733>;
      <D.24732>:
      D.24730 = data[0];
      mono_error_set_bad_image (error, image, "Invalid typeref row %d coded index 0x%08x", row, D.24730);
      D.24723 = 0;
      return D.24723;
      <D.24733>:
      D.24730 = data[0];
      D.24734 = get_coded_index_token (72, D.24730);
      if (D.24734 == 0) goto <D.24735>; else goto <D.24736>;
      <D.24735>:
      mono_error_set_bad_image (error, image, "The metadata verifier doesn\'t support null ResolutionScope tokens for typeref row %d", row);
      D.24723 = 0;
      return D.24723;
      <D.24736>:
      D.24739 = data[1];
      if (D.24739 == 0) goto <D.24737>; else goto <D.24740>;
      <D.24740>:
      D.24739 = data[1];
      D.24741 = is_valid_string_full_with_image (image, D.24739, 0);
      if (D.24741 == 0) goto <D.24737>; else goto <D.24738>;
      <D.24737>:
      D.24739 = data[1];
      mono_error_set_bad_image (error, image, "Invalid typeref row %d name token 0x%08x", row, D.24739);
      D.24723 = 0;
      return D.24723;
      <D.24738>:
      D.24742 = data[2];
      if (D.24742 != 0) goto <D.24743>; else goto <D.24744>;
      <D.24743>:
      D.24742 = data[2];
      D.24745 = is_valid_string_full_with_image (image, D.24742, 0);
      if (D.24745 == 0) goto <D.24746>; else goto <D.24747>;
      <D.24746>:
      D.24742 = data[2];
      mono_error_set_bad_image (error, image, "Invalid typeref row %d namespace token 0x%08x", row, D.24742);
      D.24723 = 0;
      return D.24723;
      <D.24747>:
      <D.24744>:
      D.24723 = 1;
      return D.24723;
    }
  finally
    {
      data = {CLOBBER};
    }
}


mono_verifier_verify_methodimpl_row (struct MonoImage * image, guint32 row, struct MonoError * error)
{
  int D.24750;
  gboolean D.24753;
  <unnamed-unsigned:24> D.24754;
  unsigned int D.24755;
  int D.24758;
  int row.198;
  unsigned int D.24760;
  struct MonoLoaderError * D.24764;
  unsigned int D.24765;
  struct MonoLoaderError * D.24769;
  int D.24774;
  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.24750 = mono_verifier_is_enabled_for_image (image);
      if (D.24750 == 0) goto <D.24751>; else goto <D.24752>;
      <D.24751>:
      D.24753 = 1;
      return D.24753;
      <D.24752>:
      D.24754 = table->rows;
      D.24755 = (unsigned int) D.24754;
      if (D.24755 <= row) goto <D.24756>; else goto <D.24757>;
      <D.24756>:
      D.24754 = table->rows;
      D.24758 = (int) D.24754;
      mono_error_set_bad_image (error, image, "Invalid methodimpl row %d - table has %d rows", row, D.24758);
      D.24753 = 0;
      return D.24753;
      <D.24757>:
      row.198 = (int) row;
      mono_metadata_decode_row (table, row.198, &data, 3);
      D.24760 = data[1];
      body = method_from_method_def_or_ref (image, D.24760, 0B);
      if (body == 0B) goto <D.24761>; else goto <D.24763>;
      <D.24763>:
      D.24764 = mono_loader_get_last_error ();
      if (D.24764 != 0B) goto <D.24761>; else goto <D.24762>;
      <D.24761>:
      mono_loader_clear_error ();
      mono_error_set_bad_image (error, image, "Invalid methodimpl body for row %x", row);
      D.24753 = 0;
      return D.24753;
      <D.24762>:
      D.24765 = data[2];
      declaration = method_from_method_def_or_ref (image, D.24765, 0B);
      if (declaration == 0B) goto <D.24766>; else goto <D.24768>;
      <D.24768>:
      D.24769 = mono_loader_get_last_error ();
      if (D.24769 != 0B) goto <D.24766>; else goto <D.24767>;
      <D.24766>:
      mono_loader_clear_error ();
      mono_error_set_bad_image (error, image, "Invalid methodimpl declaration for row %x", row);
      D.24753 = 0;
      return D.24753;
      <D.24767>:
      body_sig = mono_method_signature_checked (body, error);
      if (body_sig == 0B) goto <D.24770>; else goto <D.24771>;
      <D.24770>:
      D.24753 = 0;
      return D.24753;
      <D.24771>:
      decl_sig = mono_method_signature_checked (declaration, error);
      if (decl_sig == 0B) goto <D.24772>; else goto <D.24773>;
      <D.24772>:
      D.24753 = 0;
      return D.24753;
      <D.24773>:
      D.24774 = mono_verifier_is_signature_compatible (decl_sig, body_sig);
      if (D.24774 == 0) goto <D.24775>; else goto <D.24776>;
      <D.24775>:
      mono_error_set_bad_image (error, image, "Invalid methodimpl body signature not compatible with declaration row %x", row);
      D.24753 = 0;
      return D.24753;
      <D.24776>:
      D.24753 = 1;
      return D.24753;
    }
  finally
    {
      data = {CLOBBER};
    }
}