mono_verifier_set_mode (MiniVerifierMode mode)
{
  verifier_mode = mode;
}


mono_verifier_enable_verify_all ()
{
  verify_all = 1;
}


mono_free_verify_list (struct GSList * list)
{
  char * D.22172;
  struct MonoVerifyInfoExtended * info;
  struct GSList * tmp;

  tmp = list;
  goto <D.20365>;
  <D.20364>:
  info = tmp->data;
  D.22172 = info->info.message;
  monoeg_g_free (D.22172);
  monoeg_g_free (info);
  tmp = tmp->next;
  <D.20365>:
  if (tmp != 0B) goto <D.20364>; else goto <D.20366>;
  <D.20366>:
  monoeg_g_slist_free (list);
}


mono_verifier_is_signature_compatible (struct MonoMethodSignature * target, struct MonoMethodSignature * candidate)
{
  gboolean D.22173;

  D.22173 = mono_delegate_signature_equal (target, candidate, 0);
  return D.22173;
}


mono_delegate_signature_equal (struct MonoMethodSignature * delegate_sig, struct MonoMethodSignature * method_sig, gboolean is_static_ldftn)
{
  _Bool D.22175;
  short unsigned int D.22176;
  int D.22177;
  int D.22178;
  short unsigned int D.22179;
  int D.22180;
  gboolean D.22183;
  unsigned char D.22184;
  unsigned char D.22185;
  unsigned char D.22186;
  unsigned char D.22187;
  int D.22190;
  int D.22191;
  struct MonoType * D.22194;
  struct MonoType * D.22195;
  int D.22196;
  int i;
  int method_offset;

  D.22175 = is_static_ldftn != 0;
  method_offset = (int) D.22175;
  D.22176 = delegate_sig->param_count;
  D.22177 = (int) D.22176;
  D.22178 = D.22177 + method_offset;
  D.22179 = method_sig->param_count;
  D.22180 = (int) D.22179;
  if (D.22178 != D.22180) goto <D.22181>; else goto <D.22182>;
  <D.22181>:
  D.22183 = 0;
  return D.22183;
  <D.22182>:
  D.22184 = BIT_FIELD_REF <*delegate_sig, 8, 80>;
  D.22185 = BIT_FIELD_REF <*method_sig, 8, 80>;
  D.22186 = D.22184 ^ D.22185;
  D.22187 = D.22186 & 63;
  if (D.22187 != 0) goto <D.22188>; else goto <D.22189>;
  <D.22188>:
  D.22183 = 0;
  return D.22183;
  <D.22189>:
  i = 0;
  goto <D.20847>;
  <D.20846>:
  {
    struct MonoType * p1;
    struct MonoType * p2;

    p1 = delegate_sig->params[i];
    D.22190 = i + method_offset;
    p2 = method_sig->params[D.22190];
    D.22191 = mono_delegate_param_equal (p1, p2);
    if (D.22191 == 0) goto <D.22192>; else goto <D.22193>;
    <D.22192>:
    D.22183 = 0;
    return D.22183;
    <D.22193>:
  }
  i = i + 1;
  <D.20847>:
  D.22176 = delegate_sig->param_count;
  D.22177 = (int) D.22176;
  if (D.22177 > i) goto <D.20846>; else goto <D.20848>;
  <D.20848>:
  D.22194 = delegate_sig->ret;
  D.22195 = method_sig->ret;
  D.22196 = mono_delegate_ret_equal (D.22194, D.22195);
  if (D.22196 == 0) goto <D.22197>; else goto <D.22198>;
  <D.22197>:
  D.22183 = 0;
  return D.22183;
  <D.22198>:
  D.22183 = 1;
  return D.22183;
}


mono_delegate_param_equal (struct MonoType * delegate, struct MonoType * method)
{
  int D.22200;
  gboolean D.22203;

  D.22200 = mono_metadata_type_equal_full (delegate, method, 1);
  if (D.22200 != 0) goto <D.22201>; else goto <D.22202>;
  <D.22201>:
  D.22203 = 1;
  return D.22203;
  <D.22202>:
  D.22203 = mono_delegate_type_equal (method, delegate);
  return D.22203;
}


mono_delegate_type_equal (struct MonoType * target, struct MonoType * candidate)
{
  unsigned char D.22205;
  unsigned char D.22206;
  unsigned char D.22207;
  unsigned char D.22208;
  gboolean D.22211;
  unsigned char D.22212;
  int D.22213;
  unsigned char D.22214;
  _Bool D.22215;
  struct MonoType * D.22218;
  struct MonoType * D.22219;
  struct MonoMethodSignature * D.22222;
  struct MonoMethodSignature * D.22223;
  struct MonoClass * D.22224;
  struct MonoClass * D.22225;
  struct MonoClass * D.22228;
  struct MonoClass * D.22229;
  struct MonoClass * D.22230;
  struct MonoClass * D.22231;
  struct MonoClass * D.22234;
  struct MonoClass * D.22235;
  _Bool D.22236;
  int iftmp.0;
  struct MonoGenericParam * D.22241;
  short unsigned int D.22242;
  struct MonoGenericParam * D.22243;
  short unsigned int D.22244;
  int iftmp.1;

  D.22205 = BIT_FIELD_REF <*candidate, 8, 56>;
  D.22206 = BIT_FIELD_REF <*target, 8, 56>;
  D.22207 = D.22205 ^ D.22206;
  D.22208 = D.22207 & 64;
  if (D.22208 != 0) goto <D.22209>; else goto <D.22210>;
  <D.22209>:
  D.22211 = 0;
  return D.22211;
  <D.22210>:
  D.22212 = target->type;
  D.22213 = (int) D.22212;
  switch (D.22213) <default: <D.20828>, case 1: <D.20799>, case 2: <D.20802>, case 3: <D.20805>, case 4: <D.20800>, case 5: <D.20801>, case 6: <D.20803>, case 7: <D.20804>, case 8: <D.20806>, case 9: <D.20807>, case 10: <D.20808>, case 11: <D.20809>, case 12: <D.20810>, case 13: <D.20811>, case 14: <D.20814>, case 15: <D.20816>, case 17: <D.20825>, case 18: <D.20822>, case 19: <D.20826>, case 20: <D.20824>, case 21: <D.20818>, case 22: <D.20815>, case 24: <D.20812>, case 25: <D.20813>, case 27: <D.20817>, case 28: <D.20821>, case 29: <D.20823>, case 30: <D.20827>>
  <D.20799>:
  <D.20800>:
  <D.20801>:
  <D.20802>:
  <D.20803>:
  <D.20804>:
  <D.20805>:
  <D.20806>:
  <D.20807>:
  <D.20808>:
  <D.20809>:
  <D.20810>:
  <D.20811>:
  <D.20812>:
  <D.20813>:
  <D.20814>:
  <D.20815>:
  D.22214 = candidate->type;
  D.22212 = target->type;
  D.22215 = D.22214 == D.22212;
  D.22211 = (gboolean) D.22215;
  return D.22211;
  <D.20816>:
  D.22214 = candidate->type;
  if (D.22214 != 15) goto <D.22216>; else goto <D.22217>;
  <D.22216>:
  D.22211 = 0;
  return D.22211;
  <D.22217>:
  D.22218 = target->data.type;
  D.22219 = candidate->data.type;
  D.22211 = mono_delegate_type_equal (D.22218, D.22219);
  return D.22211;
  <D.20817>:
  D.22214 = candidate->type;
  if (D.22214 != 27) goto <D.22220>; else goto <D.22221>;
  <D.22220>:
  D.22211 = 0;
  return D.22211;
  <D.22221>:
  D.22222 = mono_type_get_signature (target);
  D.22223 = mono_type_get_signature (candidate);
  D.22211 = mono_delegate_signature_equal (D.22222, D.22223, 0);
  return D.22211;
  <D.20818>:
  {
    struct MonoClass * target_klass;
    struct MonoClass * candidate_klass;

    target_klass = mono_class_from_mono_type (target);
    candidate_klass = mono_class_from_mono_type (candidate);
    D.22211 = verifier_class_is_assignable_from (target_klass, candidate_klass);
    return D.22211;
  }
  <D.20821>:
  D.22211 = mono_type_is_reference (candidate);
  return D.22211;
  <D.20822>:
  D.22224 = target->data.klass;
  D.22225 = mono_class_from_mono_type (candidate);
  D.22211 = verifier_class_is_assignable_from (D.22224, D.22225);
  return D.22211;
  <D.20823>:
  D.22214 = candidate->type;
  if (D.22214 != 29) goto <D.22226>; else goto <D.22227>;
  <D.22226>:
  D.22211 = 0;
  return D.22211;
  <D.22227>:
  D.22228 = mono_class_from_mono_type (target);
  D.22229 = D.22228->element_class;
  D.22230 = mono_class_from_mono_type (candidate);
  D.22231 = D.22230->element_class;
  D.22211 = verifier_class_is_assignable_from (D.22229, D.22231);
  return D.22211;
  <D.20824>:
  D.22214 = candidate->type;
  if (D.22214 != 20) goto <D.22232>; else goto <D.22233>;
  <D.22232>:
  D.22211 = 0;
  return D.22211;
  <D.22233>:
  D.22211 = is_array_type_compatible (target, candidate);
  return D.22211;
  <D.20825>:
  D.22234 = mono_class_from_mono_type (candidate);
  D.22235 = mono_class_from_mono_type (target);
  D.22236 = D.22234 == D.22235;
  D.22211 = (gboolean) D.22236;
  return D.22211;
  <D.20826>:
  D.22214 = candidate->type;
  if (D.22214 == 19) goto <D.22240>; else goto <D.22238>;
  <D.22240>:
  D.22241 = target->data.generic_param;
  D.22242 = D.22241->num;
  D.22243 = candidate->data.generic_param;
  D.22244 = D.22243->num;
  if (D.22242 == D.22244) goto <D.22245>; else goto <D.22238>;
  <D.22245>:
  iftmp.0 = 1;
  goto <D.22239>;
  <D.22238>:
  iftmp.0 = 0;
  <D.22239>:
  D.22211 = iftmp.0;
  return D.22211;
  D.22211 = 0;
  return D.22211;
  <D.20827>:
  D.22214 = candidate->type;
  if (D.22214 == 30) goto <D.22249>; else goto <D.22247>;
  <D.22249>:
  D.22241 = target->data.generic_param;
  D.22242 = D.22241->num;
  D.22243 = candidate->data.generic_param;
  D.22244 = D.22243->num;
  if (D.22242 == D.22244) goto <D.22250>; else goto <D.22247>;
  <D.22250>:
  iftmp.1 = 1;
  goto <D.22248>;
  <D.22247>:
  iftmp.1 = 0;
  <D.22248>:
  D.22211 = iftmp.1;
  return D.22211;
  D.22211 = 0;
  return D.22211;
  <D.20828>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "verify.c", 2594);
  D.22211 = 0;
  return D.22211;
}


verifier_class_is_assignable_from (struct MonoClass * target, struct MonoClass * candidate)
{
  gboolean D.22254;
  int D.22255;
  unsigned int D.22261;
  unsigned int D.22262;
  unsigned char D.22264;
  unsigned int D.22268;
  unsigned int D.22269;
  unsigned char D.22271;
  int D.22273;
  unsigned char D.22276;
  struct MonoClass * D.22279;
  struct MonoClass * D.22280;
  int D.22281;
  struct MonoClass * D.22284;
  int D.22285;
  struct MonoClass * D.22288;
  int D.22289;
  struct MonoClass * D.22292;
  int D.22293;
  struct MonoClass * D.22296;
  int D.22297;
  int D.22301;
  struct MonoClass * * D.22304;
  unsigned int i.2;
  unsigned int D.22306;
  struct MonoClass * * D.22307;
  int D.22308;
  short unsigned int D.22311;
  int D.22312;
  struct MonoClass * * D.22313;
  struct MonoClass * * D.22314;
  int D.22315;
  short unsigned int D.22318;
  int D.22319;
  struct MonoClass * D.22321;
  unsigned char D.22322;
  unsigned char D.22323;
  int D.22326;
  int D.22329;
  struct MonoGenericClass * D.22337;
  struct MonoClass * D.22341;
  struct MonoClass * D.22344;
  struct MonoGenericInst * D.22347;
  struct MonoType * D.22348;
  struct MonoClass * iface_gtd;

  if (target == candidate) goto <D.22252>; else goto <D.22253>;
  <D.22252>:
  D.22254 = 1;
  return D.22254;
  <D.22253>:
  D.22255 = mono_class_has_variant_generic_params (target);
  if (D.22255 != 0) goto <D.22256>; else goto <D.22257>;
  <D.22256>:
  D.22261 = target->flags;
  D.22262 = D.22261 & 32;
  if (D.22262 != 0) goto <D.22258>; else goto <D.22263>;
  <D.22263>:
  D.22264 = target->byval_arg.type;
  if (D.22264 == 19) goto <D.22258>; else goto <D.22265>;
  <D.22265>:
  D.22264 = target->byval_arg.type;
  if (D.22264 == 30) goto <D.22258>; else goto <D.22259>;
  <D.22258>:
  D.22268 = candidate->flags;
  D.22269 = D.22268 & 32;
  if (D.22269 != 0) goto <D.22266>; else goto <D.22270>;
  <D.22270>:
  D.22271 = candidate->byval_arg.type;
  if (D.22271 == 19) goto <D.22266>; else goto <D.22272>;
  <D.22272>:
  D.22271 = candidate->byval_arg.type;
  if (D.22271 == 30) goto <D.22266>; else goto <D.22267>;
  <D.22266>:
  D.22273 = mono_class_is_variant_compatible (target, candidate, 1);
  if (D.22273 != 0) goto <D.22274>; else goto <D.22275>;
  <D.22274>:
  D.22254 = 1;
  return D.22254;
  <D.22275>:
  <D.22267>:
  D.22276 = candidate->rank;
  if (D.22276 == 1) goto <D.22277>; else goto <D.22278>;
  <D.22277>:
  D.22279 = mono_defaults.generic_ilist_class;
  D.22280 = candidate->element_class;
  D.22281 = verifier_inflate_and_check_compat (target, D.22279, D.22280);
  if (D.22281 != 0) goto <D.22282>; else goto <D.22283>;
  <D.22282>:
  D.22254 = 1;
  return D.22254;
  <D.22283>:
  D.22284 = get_icollection_class ();
  D.22280 = candidate->element_class;
  D.22285 = verifier_inflate_and_check_compat (target, D.22284, D.22280);
  if (D.22285 != 0) goto <D.22286>; else goto <D.22287>;
  <D.22286>:
  D.22254 = 1;
  return D.22254;
  <D.22287>:
  D.22288 = get_ienumerable_class ();
  D.22280 = candidate->element_class;
  D.22289 = verifier_inflate_and_check_compat (target, D.22288, D.22280);
  if (D.22289 != 0) goto <D.22290>; else goto <D.22291>;
  <D.22290>:
  D.22254 = 1;
  return D.22254;
  <D.22291>:
  D.22292 = get_ireadonlylist_class ();
  D.22280 = candidate->element_class;
  D.22293 = verifier_inflate_and_check_compat (target, D.22292, D.22280);
  if (D.22293 != 0) goto <D.22294>; else goto <D.22295>;
  <D.22294>:
  D.22254 = 1;
  return D.22254;
  <D.22295>:
  D.22296 = get_ireadonlycollection_class ();
  D.22280 = candidate->element_class;
  D.22297 = verifier_inflate_and_check_compat (target, D.22296, D.22280);
  if (D.22297 != 0) goto <D.22298>; else goto <D.22299>;
  <D.22298>:
  D.22254 = 1;
  return D.22254;
  <D.22299>:
  goto <D.22300>;
  <D.22278>:
  {
    struct MonoError error;
    int i;

    try
      {
        goto <D.20695>;
        <D.20694>:
        mono_class_setup_interfaces (candidate, &error);
        D.22301 = mono_error_ok (&error);
        if (D.22301 == 0) goto <D.22302>; else goto <D.22303>;
        <D.22302>:
        mono_error_cleanup (&error);
        D.22254 = 0;
        return D.22254;
        <D.22303>:
        i = 0;
        goto <D.20688>;
        <D.20687>:
        {
          struct MonoClass * iface;

          D.22304 = candidate->interfaces_packed;
          i.2 = (unsigned int) i;
          D.22306 = i.2 * 4;
          D.22307 = D.22304 + D.22306;
          iface = *D.22307;
          D.22308 = mono_class_is_variant_compatible (target, iface, 1);
          if (D.22308 != 0) goto <D.22309>; else goto <D.22310>;
          <D.22309>:
          D.22254 = 1;
          return D.22254;
          <D.22310>:
        }
        i = i + 1;
        <D.20688>:
        D.22311 = candidate->interface_offsets_count;
        D.22312 = (int) D.22311;
        if (D.22312 > i) goto <D.20687>; else goto <D.20689>;
        <D.20689>:
        i = 0;
        goto <D.20692>;
        <D.20691>:
        {
          struct MonoClass * iface;

          D.22313 = candidate->interfaces;
          i.2 = (unsigned int) i;
          D.22306 = i.2 * 4;
          D.22314 = D.22313 + D.22306;
          iface = *D.22314;
          D.22315 = mono_class_is_variant_compatible (target, iface, 1);
          if (D.22315 != 0) goto <D.22316>; else goto <D.22317>;
          <D.22316>:
          D.22254 = 1;
          return D.22254;
          <D.22317>:
        }
        i = i + 1;
        <D.20692>:
        D.22318 = candidate->interface_count;
        D.22319 = (int) D.22318;
        if (D.22319 > i) goto <D.20691>; else goto <D.20693>;
        <D.20693>:
        candidate = candidate->parent;
        <D.20695>:
        if (candidate != 0B) goto <D.22320>; else goto <D.20696>;
        <D.22320>:
        D.22321 = mono_defaults.object_class;
        if (D.22321 != candidate) goto <D.20694>; else goto <D.20696>;
        <D.20696>:
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  <D.22300>:
  goto <D.22260>;
  <D.22259>:
  D.22322 = BIT_FIELD_REF <*target, 8, 184>;
  D.22323 = D.22322 & 1;
  if (D.22323 != 0) goto <D.22324>; else goto <D.22325>;
  <D.22324>:
  D.22326 = mono_class_is_variant_compatible (target, candidate, 1);
  if (D.22326 != 0) goto <D.22327>; else goto <D.22328>;
  <D.22327>:
  D.22254 = 1;
  return D.22254;
  <D.22328>:
  <D.22325>:
  <D.22260>:
  D.22254 = 0;
  return D.22254;
  <D.22257>:
  D.22329 = mono_class_is_assignable_from (target, candidate);
  if (D.22329 != 0) goto <D.22330>; else goto <D.22331>;
  <D.22330>:
  D.22254 = 1;
  return D.22254;
  <D.22331>:
  D.22261 = target->flags;
  D.22262 = D.22261 & 32;
  if (D.22262 == 0) goto <D.22335>; else goto <D.22332>;
  <D.22335>:
  D.22264 = target->byval_arg.type;
  if (D.22264 != 19) goto <D.22336>; else goto <D.22332>;
  <D.22336>:
  D.22264 = target->byval_arg.type;
  if (D.22264 != 30) goto <D.22333>; else goto <D.22332>;
  <D.22332>:
  D.22337 = target->generic_class;
  if (D.22337 == 0B) goto <D.22333>; else goto <D.22338>;
  <D.22338>:
  D.22276 = candidate->rank;
  if (D.22276 != 1) goto <D.22333>; else goto <D.22334>;
  <D.22333>:
  D.22254 = 0;
  return D.22254;
  <D.22334>:
  D.22337 = target->generic_class;
  iface_gtd = D.22337->container_class;
  D.22279 = mono_defaults.generic_ilist_class;
  if (D.22279 != iface_gtd) goto <D.22339>; else goto <D.22340>;
  <D.22339>:
  D.22341 = get_icollection_class ();
  if (D.22341 != iface_gtd) goto <D.22342>; else goto <D.22343>;
  <D.22342>:
  D.22344 = get_ienumerable_class ();
  if (D.22344 != iface_gtd) goto <D.22345>; else goto <D.22346>;
  <D.22345>:
  D.22254 = 0;
  return D.22254;
  <D.22346>:
  <D.22343>:
  <D.22340>:
  D.22337 = target->generic_class;
  D.22347 = D.22337->context.class_inst;
  D.22348 = D.22347->type_argv[0];
  target = mono_class_from_mono_type (D.22348);
  candidate = candidate->element_class;
  D.22254 = 1;
  return D.22254;
}


get_ireadonlylist_class ()
{
  struct MonoClass * generic_ireadonlylist_class.3;
  struct MonoImage * D.22355;
  struct MonoClass * generic_ireadonlylist_class.4;
  struct MonoClass * D.22357;
  static struct MonoClass * generic_ireadonlylist_class = 0B;

  generic_ireadonlylist_class.3 = generic_ireadonlylist_class;
  if (generic_ireadonlylist_class.3 == 0B) goto <D.22353>; else goto <D.22354>;
  <D.22353>:
  D.22355 = mono_defaults.corlib;
  generic_ireadonlylist_class.4 = mono_class_from_name (D.22355, "System.Collections.Generic", "IReadOnlyList`1");
  generic_ireadonlylist_class = generic_ireadonlylist_class.4;
  <D.22354>:
  D.22357 = generic_ireadonlylist_class;
  return D.22357;
}


get_ireadonlycollection_class ()
{
  struct MonoClass * generic_ireadonlycollection_class.5;
  struct MonoImage * D.22362;
  struct MonoClass * generic_ireadonlycollection_class.6;
  struct MonoClass * D.22364;
  static struct MonoClass * generic_ireadonlycollection_class = 0B;

  generic_ireadonlycollection_class.5 = generic_ireadonlycollection_class;
  if (generic_ireadonlycollection_class.5 == 0B) goto <D.22360>; else goto <D.22361>;
  <D.22360>:
  D.22362 = mono_defaults.corlib;
  generic_ireadonlycollection_class.6 = mono_class_from_name (D.22362, "System.Collections.Generic", "IReadOnlyCollection`1");
  generic_ireadonlycollection_class = generic_ireadonlycollection_class.6;
  <D.22361>:
  D.22364 = generic_ireadonlycollection_class;
  return D.22364;
}


verifier_inflate_and_check_compat (struct MonoClass * target, struct MonoClass * gtd, struct MonoClass * arg)
{
  gboolean D.22368;
  int D.22369;
  struct MonoClass * tmp;

  tmp = inflate_class_one_arg (gtd, arg);
  if (tmp == 0B) goto <D.22366>; else goto <D.22367>;
  <D.22366>:
  D.22368 = 0;
  return D.22368;
  <D.22367>:
  D.22369 = mono_class_is_variant_compatible (target, tmp, 1);
  if (D.22369 != 0) goto <D.22370>; else goto <D.22371>;
  <D.22370>:
  D.22368 = 1;
  return D.22368;
  <D.22371>:
  D.22368 = 0;
  return D.22368;
}


inflate_class_one_arg (struct MonoClass * gtype, struct MonoClass * arg0)
{
  struct MonoType * D.22373;
  struct MonoClass * D.22374;
  struct MonoType * args[1];

  try
    {
      D.22373 = &arg0->byval_arg;
      args[0] = D.22373;
      D.22374 = mono_class_bind_generic_parameters (gtype, 1, &args, 0);
      return D.22374;
    }
  finally
    {
      args = {CLOBBER};
    }
}


get_icollection_class ()
{
  struct MonoClass * generic_icollection_class.7;
  struct MonoImage * D.22380;
  struct MonoClass * generic_icollection_class.8;
  struct MonoClass * D.22382;
  static struct MonoClass * generic_icollection_class = 0B;

  generic_icollection_class.7 = generic_icollection_class;
  if (generic_icollection_class.7 == 0B) goto <D.22378>; else goto <D.22379>;
  <D.22378>:
  D.22380 = mono_defaults.corlib;
  generic_icollection_class.8 = mono_class_from_name (D.22380, "System.Collections.Generic", "ICollection`1");
  generic_icollection_class = generic_icollection_class.8;
  <D.22379>:
  D.22382 = generic_icollection_class;
  return D.22382;
}


get_ienumerable_class ()
{
  struct MonoClass * generic_ienumerable_class.9;
  struct MonoImage * D.22387;
  struct MonoClass * generic_ienumerable_class.10;
  struct MonoClass * D.22389;
  static struct MonoClass * generic_ienumerable_class = 0B;

  generic_ienumerable_class.9 = generic_ienumerable_class;
  if (generic_ienumerable_class.9 == 0B) goto <D.22385>; else goto <D.22386>;
  <D.22385>:
  D.22387 = mono_defaults.corlib;
  generic_ienumerable_class.10 = mono_class_from_name (D.22387, "System.Collections.Generic", "IEnumerable`1");
  generic_ienumerable_class = generic_ienumerable_class.10;
  <D.22386>:
  D.22389 = generic_ienumerable_class;
  return D.22389;
}


is_array_type_compatible (struct MonoType * target, struct MonoType * candidate)
{
  unsigned char D.22391;
  _Bool D.22392;
  long int D.22393;
  long int D.22394;
  unsigned char D.22397;
  _Bool D.22398;
  long int D.22399;
  long int D.22400;
  unsigned char D.22403;
  unsigned char D.22404;
  gboolean D.22407;
  struct MonoClass * D.22408;
  struct MonoClass * D.22409;
  struct MonoArrayType * left;
  struct MonoArrayType * right;

  left = target->data.array;
  right = candidate->data.array;
  D.22391 = target->type;
  D.22392 = D.22391 != 20;
  D.22393 = (long int) D.22392;
  D.22394 = __builtin_expect (D.22393, 0);
  if (D.22394 != 0) goto <D.22395>; else goto <D.22396>;
  <D.22395>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "verify.c", 1880, "target->type == MONO_TYPE_ARRAY");
  <D.22396>:
  D.22397 = candidate->type;
  D.22398 = D.22397 != 20;
  D.22399 = (long int) D.22398;
  D.22400 = __builtin_expect (D.22399, 0);
  if (D.22400 != 0) goto <D.22401>; else goto <D.22402>;
  <D.22401>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "verify.c", 1881, "candidate->type == MONO_TYPE_ARRAY");
  <D.22402>:
  D.22403 = left->rank;
  D.22404 = right->rank;
  if (D.22403 != D.22404) goto <D.22405>; else goto <D.22406>;
  <D.22405>:
  D.22407 = 0;
  return D.22407;
  <D.22406>:
  D.22408 = left->eklass;
  D.22409 = right->eklass;
  D.22407 = verifier_class_is_assignable_from (D.22408, D.22409);
  return D.22407;
}


mono_delegate_ret_equal (struct MonoType * delegate, struct MonoType * method)
{
  int D.22411;
  gboolean D.22414;

  D.22411 = mono_metadata_type_equal_full (delegate, method, 1);
  if (D.22411 != 0) goto <D.22412>; else goto <D.22413>;
  <D.22412>:
  D.22414 = 1;
  return D.22414;
  <D.22413>:
  D.22414 = mono_delegate_type_equal (delegate, method);
  return D.22414;
}


mono_method_verify (struct MonoMethod * method, int level)
{
  short unsigned int D.22418;
  int D.22419;
  int D.22420;
  short unsigned int D.22422;
  int D.22423;
  int D.22424;
  struct GSList * D.22425;
  struct MonoMethodSignature * D.22426;
  struct MonoMethodSignature * D.22427;
  gchar * D.22430;
  struct GSList * D.22431;
  struct GSList * D.22432;
  unsigned char D.22433;
  unsigned char D.22434;
  struct MonoClass * D.22437;
  unsigned char D.22438;
  unsigned char D.22439;
  unsigned char D.22442;
  unsigned char D.22443;
  gchar * D.22446;
  struct GSList * D.22447;
  struct MonoMethodHeader * D.22448;
  struct MonoMethodHeader * D.22449;
  gchar * D.22452;
  struct GSList * D.22453;
  unsigned int D.22454;
  short unsigned int D.22455;
  int D.22456;
  <unnamed-unsigned:1> D.22457;
  int D.22458;
  int D.22459;
  <unnamed-unsigned:15> D.22460;
  int D.22461;
  int D.22462;
  unsigned int D.22463;
  void * D.22464;
  int D.22465;
  struct ILCodeDesc * D.22466;
  short unsigned int D.22467;
  int D.22468;
  struct MonoType *[0:] * D.22469;
  unsigned int D.22470;
  unsigned int D.22471;
  void * D.22472;
  int D.22473;
  unsigned char D.22476;
  unsigned char D.22477;
  int D.22482;
  int D.22484;
  int D.22485;
  gchar * D.22486;
  struct GSList * D.22487;
  int D.22488;
  int D.22491;
  unsigned int D.22492;
  unsigned int D.22493;
  void * D.22494;
  unsigned char D.22495;
  unsigned char D.22496;
  struct MonoType * * D.22499;
  struct MonoType * iftmp.11;
  unsigned char D.22501;
  unsigned char D.22502;
  unsigned int D.22506;
  unsigned int D.22507;
  struct MonoType * * D.22508;
  struct MonoType *[0:] * D.22509;
  unsigned int D.22510;
  unsigned int D.22511;
  unsigned char D.22512;
  struct MonoGenericContainer * D.22519;
  struct MonoGenericContainer * D.22523;
  struct MonoType * * D.22525;
  unsigned int i.12;
  unsigned int D.22527;
  struct MonoType * * D.22528;
  struct MonoType * D.22529;
  struct MonoGenericContext * D.22530;
  struct MonoType * D.22531;
  int D.22532;
  struct MonoType * iftmp.13;
  gchar * D.22539;
  struct GSList * D.22540;
  struct MonoType * * D.22541;
  struct MonoType * D.22542;
  struct MonoType * D.22543;
  int D.22544;
  struct MonoType * iftmp.14;
  gchar * D.22551;
  struct GSList * D.22552;
  int D.22553;
  int D.22555;
  gchar * D.22558;
  struct GSList * D.22559;
  int D.22560;
  int D.22562;
  gchar * D.22565;
  struct GSList * D.22566;
  struct MonoExceptionClause * D.22568;
  unsigned int D.22569;
  unsigned int D.22572;
  int D.22573;
  unsigned int D.22574;
  unsigned int D.22576;
  unsigned int D.22577;
  unsigned int D.22579;
  gchar * D.22580;
  struct GSList * D.22581;
  gchar * D.22584;
  struct GSList * D.22585;
  unsigned int D.22588;
  unsigned int D.22590;
  unsigned int D.22591;
  unsigned int D.22593;
  gchar * D.22594;
  struct GSList * D.22595;
  gchar * D.22598;
  struct GSList * D.22599;
  uint32_t iftmp.15;
  unsigned int D.22605;
  gchar * D.22610;
  struct GSList * D.22611;
  unsigned int D.22614;
  gchar * D.22617;
  struct GSList * D.22618;
  gchar * D.22621;
  struct GSList * D.22622;
  unsigned int n.16;
  unsigned int D.22624;
  struct MonoExceptionClause * D.22625;
  <unnamed-unsigned:15> D.22626;
  int D.22627;
  unsigned int D.22630;
  struct ILCodeDesc * D.22631;
  short unsigned int D.22632;
  short unsigned int D.22633;
  unsigned int D.22636;
  struct ILCodeDesc * D.22637;
  short unsigned int D.22638;
  short unsigned int D.22639;
  unsigned int D.22642;
  struct ILCodeDesc * D.22643;
  short unsigned int D.22644;
  short unsigned int D.22645;
  struct MonoClass * D.22648;
  gchar * D.22651;
  struct GSList * D.22652;
  struct MonoType * D.22653;
  int D.22654;
  unsigned int D.22656;
  struct ILCodeDesc * D.22657;
  unsigned int D.22661;
  struct ILCodeDesc * D.22662;
  struct MonoClass * D.22663;
  int D.22666;
  const char * D.22669;
  gchar * D.22670;
  struct GSList * D.22671;
  _Bool D.22672;
  long int D.22673;
  long int D.22674;
  int ip.17;
  int code_start.18;
  int D.22679;
  int D.22680;
  unsigned int D.22681;
  gchar * D.22684;
  struct GSList * D.22685;
  unsigned char D.22690;
  int D.22691;
  gchar * D.22692;
  struct GSList * D.22693;
  unsigned int op_size.19;
  unsigned int D.22697;
  unsigned int op_size.20;
  unsigned int D.22700;
  gchar * D.22701;
  struct GSList * D.22702;
  int op.21;
  int D.22706;
  const char * D.22709;
  gchar * D.22710;
  struct GSList * D.22711;
  unsigned int D.22712;
  unsigned int D.22713;
  unsigned int D.22714;
  gchar * D.22722;
  struct GSList * D.22723;
  unsigned int D.22726;
  unsigned int D.22727;
  unsigned int D.22728;
  unsigned int D.22733;
  gchar * D.22736;
  struct GSList * D.22737;
  gchar * D.22742;
  struct GSList * D.22743;
  gchar * D.22752;
  struct GSList * D.22753;
  gchar * D.22761;
  struct GSList * D.22762;
  short unsigned int D.22767;
  gchar * D.22772;
  struct GSList * D.22773;
  unsigned char D.22775;
  unsigned char D.22776;
  unsigned int D.22779;
  struct ILCodeDesc * D.22780;
  short unsigned int D.22781;
  short unsigned int D.22782;
  sizetype op_size.22;
  int D.22787;
  unsigned int D.22788;
  unsigned int D.22789;
  struct ILCodeDesc * D.22790;
  int D.22791;
  unsigned int D.22792;
  const unsigned char * D.22795;
  unsigned int ip.23;
  unsigned int D.22798;
  gchar * D.22799;
  struct GSList * D.22800;
  const unsigned char * D.22801;
  unsigned char D.22802;
  unsigned int D.22803;
  _Bool D.22804;
  int D.22805;
  unsigned int D.22806;
  int D.22807;
  int D.22809;
  unsigned int D.22810;
  int D.22811;
  unsigned int D.22812;
  gchar * D.22816;
  struct GSList * D.22817;
  unsigned int D.22818;
  gchar * D.22822;
  struct GSList * D.22823;
  int D.22824;
  struct MonoClass * D.22827;
  struct MonoType * D.22828;
  gchar * D.22832;
  struct GSList * D.22833;
  int D.22834;
  const unsigned char * D.22839;
  gchar * D.22841;
  struct GSList * D.22842;
  int D.22843;
  const unsigned char * D.22848;
  gchar * D.22850;
  struct GSList * D.22851;
  int D.22852;
  struct MonoClass * D.22855;
  struct MonoType * D.22856;
  gchar * D.22860;
  struct GSList * D.22861;
  int D.22862;
  struct MonoClass * D.22865;
  struct MonoType * D.22866;
  gchar * D.22870;
  struct GSList * D.22871;
  int D.22872;
  int D.22875;
  struct MonoClass * D.22878;
  struct MonoType * D.22879;
  gchar * D.22883;
  struct GSList * D.22884;
  signed char D.22885;
  int D.22886;
  int D.22887;
  gchar * D.22891;
  struct GSList * D.22892;
  gchar * D.22896;
  struct GSList * D.22897;
  unsigned int D.22898;
  int D.22899;
  int D.22900;
  gchar * D.22904;
  struct GSList * D.22905;
  unsigned int D.22906;
  int D.22907;
  int D.22908;
  gchar * D.22912;
  struct GSList * D.22913;
  _Bool D.22914;
  int D.22915;
  gchar * D.22916;
  struct GSList * D.22917;
  int D.22918;
  int D.22920;
  struct ILStackDesc * D.22922;
  gchar * D.22926;
  struct GSList * D.22927;
  gchar * D.22930;
  struct GSList * D.22931;
  int D.22932;
  gchar * D.22935;
  struct GSList * D.22936;
  gchar * D.22940;
  struct GSList * D.22941;
  gchar * D.22947;
  struct GSList * D.22948;
  unsigned int D.22949;
  int D.22950;
  _Bool D.22951;
  int D.22952;
  gchar * D.22956;
  struct GSList * D.22957;
  gchar * D.22961;
  struct GSList * D.22962;
  gchar * D.22968;
  struct GSList * D.22969;
  gchar * D.22973;
  struct GSList * D.22974;
  gchar * D.22978;
  struct GSList * D.22979;
  unsigned int D.22980;
  int D.22981;
  int D.22982;
  gchar * D.22986;
  struct GSList * D.22987;
  unsigned int D.22988;
  int D.22989;
  int D.22990;
  gchar * D.22994;
  struct GSList * D.22995;
  gchar * D.22998;
  struct GSList * D.22999;
  unsigned int D.23002;
  const unsigned char * D.23003;
  unsigned int D.23005;
  gchar * D.23006;
  struct GSList * D.23007;
  int entries.24;
  gchar * D.23012;
  struct GSList * D.23013;
  unsigned int D.23014;
  int D.23015;
  gchar * D.23019;
  struct GSList * D.23020;
  unsigned int D.23021;
  int D.23022;
  gchar * D.23026;
  struct GSList * D.23027;
  unsigned int D.23028;
  gchar * D.23032;
  struct GSList * D.23033;
  unsigned int D.23034;
  int D.23035;
  gchar * D.23039;
  struct GSList * D.23040;
  unsigned int D.23041;
  int D.23042;
  const char * iftmp.25;
  gchar * D.23047;
  struct GSList * D.23048;
  gchar * D.23052;
  struct GSList * D.23053;
  unsigned int D.23054;
  int D.23055;
  gchar * D.23059;
  struct GSList * D.23060;
  unsigned int D.23061;
  int D.23062;
  _Bool D.23063;
  int D.23064;
  gchar * D.23068;
  struct GSList * D.23069;
  unsigned int D.23070;
  int D.23071;
  _Bool D.23072;
  int D.23073;
  gchar * D.23077;
  struct GSList * D.23078;
  unsigned int D.23079;
  int D.23080;
  gchar * D.23084;
  struct GSList * D.23085;
  unsigned int D.23086;
  int D.23087;
  gchar * D.23091;
  struct GSList * D.23092;
  unsigned int D.23093;
  int D.23094;
  gchar * D.23098;
  struct GSList * D.23099;
  unsigned int D.23100;
  int D.23101;
  gchar * D.23105;
  struct GSList * D.23106;
  unsigned int D.23107;
  int D.23108;
  gchar * D.23112;
  struct GSList * D.23113;
  unsigned int D.23114;
  int D.23115;
  gchar * D.23119;
  struct GSList * D.23120;
  unsigned int D.23121;
  int D.23122;
  gchar * D.23126;
  struct GSList * D.23127;
  unsigned int D.23128;
  int D.23129;
  gchar * D.23133;
  struct GSList * D.23134;
  unsigned int D.23135;
  int D.23136;
  gchar * D.23140;
  struct GSList * D.23141;
  unsigned int D.23142;
  int D.23143;
  gchar * D.23147;
  struct GSList * D.23148;
  unsigned int D.23149;
  int D.23150;
  gchar * D.23154;
  struct GSList * D.23155;
  unsigned int D.23156;
  int D.23157;
  int D.23158;
  gchar * D.23161;
  struct GSList * D.23162;
  gchar * D.23166;
  struct GSList * D.23167;
  unsigned int D.23168;
  unsigned int D.23169;
  int D.23170;
  gchar * D.23174;
  struct GSList * D.23175;
  gchar * D.23179;
  struct GSList * D.23180;
  const unsigned char * D.23183;
  gchar * D.23185;
  struct GSList * D.23186;
  short unsigned int D.23187;
  unsigned int D.23188;
  unsigned int D.23189;
  gchar * D.23193;
  struct GSList * D.23194;
  short unsigned int D.23195;
  unsigned int D.23196;
  int D.23197;
  unsigned char D.23199;
  gchar * D.23202;
  struct GSList * D.23203;
  struct ILStackDesc * D.23204;
  struct MonoClass * D.23205;
  struct MonoType * D.23206;
  gchar * D.23210;
  struct GSList * D.23211;
  unsigned int D.23212;
  gchar * D.23216;
  struct GSList * D.23217;
  unsigned int D.23218;
  gchar * D.23222;
  struct GSList * D.23223;
  short unsigned int D.23224;
  unsigned int D.23225;
  _Bool D.23226;
  int D.23227;
  gchar * D.23231;
  struct GSList * D.23232;
  short unsigned int D.23233;
  unsigned int D.23234;
  _Bool D.23235;
  int D.23236;
  gchar * D.23237;
  struct GSList * D.23238;
  gchar * D.23242;
  struct GSList * D.23243;
  unsigned char D.23246;
  _Bool D.23247;
  _Bool D.23248;
  _Bool D.23249;
  gchar * D.23252;
  struct GSList * D.23253;
  gchar * D.23257;
  struct GSList * D.23258;
  unsigned int D.23259;
  int D.23260;
  gchar * D.23264;
  struct GSList * D.23265;
  unsigned int D.23266;
  int D.23267;
  struct MonoType * D.23268;
  unsigned int D.23269;
  unsigned int D.23270;
  int D.23271;
  gchar * D.23276;
  struct GSList * D.23277;
  int D.23280;
  gchar * D.23285;
  struct GSList * D.23286;
  int D.23289;
  gchar * D.23292;
  struct GSList * D.23293;
  gchar * D.23297;
  struct GSList * D.23298;
  unsigned int D.23299;
  int D.23300;
  gchar * D.23301;
  struct GSList * D.23302;
  gchar * D.23303;
  struct GSList * D.23304;
  unsigned int D.23309;
  struct ILCodeDesc * D.23310;
  short unsigned int D.23311;
  short unsigned int D.23312;
  unsigned int D.23313;
  int D.23315;
  unsigned int D.23318;
  gchar * D.23321;
  struct GSList * D.23322;
  unsigned int D.23323;
  gchar * D.23326;
  struct GSList * D.23327;
  unsigned int D.23328;
  gchar * D.23331;
  struct GSList * D.23332;
  unsigned int D.23333;
  gchar * D.23336;
  struct GSList * D.23337;
  _Bool D.23339;
  _Bool D.23340;
  _Bool D.23341;
  gchar * D.23348;
  struct GSList * D.23349;
  unsigned int D.23350;
  struct ILCodeDesc * D.23351;
  short unsigned int D.23352;
  int D.23353;
  int D.23354;
  int D.23357;
  gchar * D.23360;
  struct GSList * D.23361;
  int D.23362;
  gchar * D.23368;
  struct GSList * D.23369;
  int D.23372;
  int D.23375;
  gchar * D.23381;
  struct GSList * D.23382;
  int D.23385;
  gchar * D.23393;
  struct GSList * D.23394;
  unsigned int i.26;
  struct MonoMethod * D.23399;
  int D.23400;
  int D.23403;
  struct MonoClass * D.23406;
  unsigned char D.23407;
  unsigned char D.23408;
  struct MonoClass * D.23415;
  unsigned char D.23417;
  gchar * D.23422;
  struct GSList * D.23423;
  gchar * D.23429;
  struct GSList * D.23430;
  struct ILStackDesc * D.23435;
  unsigned int i.27;
  void * D.23439;
  struct GSList * D.23440;
  struct GSList * D.23441;
  struct ILStackDesc * D.23446;
  struct MonoError error;
  const unsigned char * ip;
  const unsigned char * code_start;
  const unsigned char * end;
  struct MonoSimpleBasicBlock * bb;
  struct MonoSimpleBasicBlock * original_bb;
  int i;
  int n;
  int need_merge;
  int start;
  guint token;
  guint ip_offset;
  guint prefix;
  struct MonoGenericContext * generic_context;
  struct MonoImage * image;
  struct VerifyContext ctx;
  struct GSList * tmp;
  void cleanup = <<< error >>>;

  try
    {
      bb = 0B;
      original_bb = 0B;
      need_merge = 0;
      start = 0;
      ip_offset = 0;
      prefix = 0;
      generic_context = 0B;
      D.22418 = method->iflags;
      D.22419 = (int) D.22418;
      D.22420 = D.22419 & 4099;
      if (D.22420 != 0) goto <D.22416>; else goto <D.22421>;
      <D.22421>:
      D.22422 = method->flags;
      D.22423 = (int) D.22422;
      D.22424 = D.22423 & 9216;
      if (D.22424 != 0) goto <D.22416>; else goto <D.22417>;
      <D.22416>:
      D.22425 = 0B;
      return D.22425;
      <D.22417>:
      memset (&ctx, 0, 112);
      D.22426 = mono_method_signature (method);
      ctx.signature = D.22426;
      D.22427 = ctx.signature;
      if (D.22427 == 0B) goto <D.22428>; else goto <D.22429>;
      <D.22428>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22430 = monoeg_g_strdup_printf ("Could not decode method signature");
        vinfo->info.message = D.22430;
        vinfo->exception_type = 3;
        D.22431 = ctx.list;
        D.22432 = monoeg_g_slist_prepend (D.22431, vinfo);
        ctx.list = D.22432;
      }
      ctx.valid = 0;
      D.22425 = ctx.list;
      return D.22425;
      <D.22429>:
      D.22433 = BIT_FIELD_REF <*method, 8, 168>;
      D.22434 = D.22433 & 8;
      if (D.22434 == 0) goto <D.22435>; else goto <D.22436>;
      <D.22435>:
      D.22437 = method->klass;
      D.22438 = BIT_FIELD_REF <*D.22437, 8, 192>;
      D.22439 = D.22438 & 4;
      if (D.22439 == 0) goto <D.22440>; else goto <D.22441>;
      <D.22440>:
      D.22427 = ctx.signature;
      D.22442 = BIT_FIELD_REF <*D.22427, 8, 88>;
      D.22443 = D.22442 & 4;
      if (D.22443 != 0) goto <D.22444>; else goto <D.22445>;
      <D.22444>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22446 = monoeg_g_strdup_printf ("Method and signature don\'t match in terms of genericity");
        vinfo->info.message = D.22446;
        vinfo->exception_type = 3;
        D.22431 = ctx.list;
        D.22447 = monoeg_g_slist_prepend (D.22431, vinfo);
        ctx.list = D.22447;
      }
      ctx.valid = 0;
      D.22425 = ctx.list;
      return D.22425;
      <D.22445>:
      <D.22441>:
      <D.22436>:
      D.22448 = mono_method_get_header (method);
      ctx.header = D.22448;
      D.22449 = ctx.header;
      if (D.22449 == 0B) goto <D.22450>; else goto <D.22451>;
      <D.22450>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22452 = monoeg_g_strdup_printf ("Could not decode method header");
        vinfo->info.message = D.22452;
        vinfo->exception_type = 3;
        D.22431 = ctx.list;
        D.22453 = monoeg_g_slist_prepend (D.22431, vinfo);
        ctx.list = D.22453;
      }
      ctx.valid = 0;
      D.22425 = ctx.list;
      return D.22425;
      <D.22451>:
      ctx.method = method;
      D.22449 = ctx.header;
      ip = D.22449->code;
      code_start = ip;
      D.22449 = ctx.header;
      D.22454 = D.22449->code_size;
      end = ip + D.22454;
      D.22437 = method->klass;
      image = D.22437->image;
      ctx.image = image;
      D.22427 = ctx.signature;
      D.22455 = D.22427->param_count;
      D.22456 = (int) D.22455;
      D.22427 = ctx.signature;
      D.22457 = D.22427->hasthis;
      D.22458 = (int) D.22457;
      D.22459 = D.22456 + D.22458;
      ctx.max_args = D.22459;
      D.22449 = ctx.header;
      D.22460 = D.22449->max_stack;
      D.22461 = (int) D.22460;
      ctx.max_stack = D.22461;
      ctx.valid = 1;
      D.22462 = ctx.valid;
      ctx.verifiable = D.22462;
      ctx.level = level;
      D.22449 = ctx.header;
      D.22454 = D.22449->code_size;
      D.22463 = D.22454 * 12;
      D.22464 = monoeg_malloc (D.22463);
      ctx.code = D.22464;
      D.22449 = ctx.header;
      D.22454 = D.22449->code_size;
      D.22465 = (int) D.22454;
      ctx.code_size = D.22465;
      D.22466 = ctx.code;
      D.22449 = ctx.header;
      D.22454 = D.22449->code_size;
      D.22463 = D.22454 * 12;
      memset (D.22466, 0, D.22463);
      D.22449 = ctx.header;
      D.22467 = D.22449->num_locals;
      D.22468 = (int) D.22467;
      ctx.num_locals = D.22468;
      D.22449 = ctx.header;
      D.22469 = &D.22449->locals;
      D.22449 = ctx.header;
      D.22467 = D.22449->num_locals;
      D.22470 = (unsigned int) D.22467;
      D.22471 = D.22470 * 4;
      D.22472 = monoeg_g_memdup (D.22469, D.22471);
      ctx.locals = D.22472;
      D.22473 = ctx.num_locals;
      if (D.22473 > 0) goto <D.22474>; else goto <D.22475>;
      <D.22474>:
      D.22449 = ctx.header;
      D.22476 = BIT_FIELD_REF <*D.22449, 8, 88>;
      D.22477 = D.22476 & 128;
      if (D.22477 == 0) goto <D.22478>; else goto <D.22479>;
      <D.22478>:
      D.22482 = ctx.verifiable;
      if (D.22482 != 0) goto <D.22480>; else goto <D.22483>;
      <D.22483>:
      D.22484 = ctx.level;
      D.22485 = D.22484 & 128;
      if (D.22485 != 0) goto <D.22480>; else goto <D.22481>;
      <D.22480>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 8;
        D.22486 = monoeg_g_strdup_printf ("Method with locals variable but without init locals set");
        vinfo->info.message = D.22486;
        vinfo->exception_type = 4;
        D.22431 = ctx.list;
        D.22487 = monoeg_g_slist_prepend (D.22431, vinfo);
        ctx.list = D.22487;
      }
      ctx.verifiable = 0;
      D.22484 = ctx.level;
      D.22488 = D.22484 & 16;
      if (D.22488 != 0) goto <D.22489>; else goto <D.22490>;
      <D.22489>:
      ctx.valid = 0;
      <D.22490>:
      <D.22481>:
      <D.22479>:
      <D.22475>:
      D.22491 = ctx.max_args;
      D.22492 = (unsigned int) D.22491;
      D.22493 = D.22492 * 4;
      D.22494 = monoeg_malloc (D.22493);
      ctx.params = D.22494;
      D.22427 = ctx.signature;
      D.22495 = BIT_FIELD_REF <*D.22427, 8, 80>;
      D.22496 = D.22495 & 64;
      if (D.22496 != 0) goto <D.22497>; else goto <D.22498>;
      <D.22497>:
      D.22499 = ctx.params;
      D.22437 = method->klass;
      D.22501 = BIT_FIELD_REF <*D.22437, 8, 160>;
      D.22502 = D.22501 & 8;
      if (D.22502 != 0) goto <D.22503>; else goto <D.22504>;
      <D.22503>:
      D.22437 = method->klass;
      iftmp.11 = &D.22437->this_arg;
      goto <D.22505>;
      <D.22504>:
      D.22437 = method->klass;
      iftmp.11 = &D.22437->byval_arg;
      <D.22505>:
      *D.22499 = iftmp.11;
      <D.22498>:
      D.22499 = ctx.params;
      D.22427 = ctx.signature;
      D.22457 = D.22427->hasthis;
      D.22506 = (unsigned int) D.22457;
      D.22507 = D.22506 * 4;
      D.22508 = D.22499 + D.22507;
      D.22427 = ctx.signature;
      D.22509 = &D.22427->params;
      D.22427 = ctx.signature;
      D.22455 = D.22427->param_count;
      D.22510 = (unsigned int) D.22455;
      D.22511 = D.22510 * 4;
      memcpy (D.22508, D.22509, D.22511);
      D.22427 = ctx.signature;
      D.22442 = BIT_FIELD_REF <*D.22427, 8, 88>;
      D.22512 = D.22442 & 2;
      if (D.22512 != 0) goto <D.22513>; else goto <D.22514>;
      <D.22513>:
      generic_context = mono_method_get_context (method);
      ctx.generic_context = generic_context;
      <D.22514>:
      if (generic_context == 0B) goto <D.22517>; else goto <D.22518>;
      <D.22517>:
      D.22437 = method->klass;
      D.22519 = D.22437->generic_container;
      if (D.22519 != 0B) goto <D.22515>; else goto <D.22520>;
      <D.22520>:
      D.22433 = BIT_FIELD_REF <*method, 8, 168>;
      D.22434 = D.22433 & 8;
      if (D.22434 != 0) goto <D.22515>; else goto <D.22516>;
      <D.22515>:
      D.22433 = BIT_FIELD_REF <*method, 8, 168>;
      D.22434 = D.22433 & 8;
      if (D.22434 != 0) goto <D.22521>; else goto <D.22522>;
      <D.22521>:
      D.22523 = mono_method_get_generic_container (method);
      generic_context = &D.22523->context;
      ctx.generic_context = generic_context;
      goto <D.22524>;
      <D.22522>:
      D.22437 = method->klass;
      D.22519 = D.22437->generic_container;
      generic_context = &D.22519->context;
      ctx.generic_context = generic_context;
      <D.22524>:
      <D.22516>:
      <D.22518>:
      i = 0;
      goto <D.21622>;
      <D.21621>:
      {
        struct MonoType * uninflated;

        D.22525 = ctx.locals;
        i.12 = (unsigned int) i;
        D.22527 = i.12 * 4;
        D.22528 = D.22525 + D.22527;
        uninflated = *D.22528;
        D.22525 = ctx.locals;
        i.12 = (unsigned int) i;
        D.22527 = i.12 * 4;
        D.22528 = D.22525 + D.22527;
        D.22525 = ctx.locals;
        i.12 = (unsigned int) i;
        D.22527 = i.12 * 4;
        D.22528 = D.22525 + D.22527;
        D.22529 = *D.22528;
        D.22530 = ctx.generic_context;
        D.22531 = mono_class_inflate_generic_type_checked (D.22529, D.22530, &error);
        *D.22528 = D.22531;
        D.22532 = mono_error_ok (&error);
        if (D.22532 == 0) goto <D.22533>; else goto <D.22534>;
        <D.22533>:
        {
          char * name;

          D.22525 = ctx.locals;
          i.12 = (unsigned int) i;
          D.22527 = i.12 * 4;
          D.22528 = D.22525 + D.22527;
          D.22529 = *D.22528;
          if (D.22529 != 0B) goto <D.22536>; else goto <D.22537>;
          <D.22536>:
          D.22525 = ctx.locals;
          i.12 = (unsigned int) i;
          D.22527 = i.12 * 4;
          D.22528 = D.22525 + D.22527;
          iftmp.13 = *D.22528;
          goto <D.22538>;
          <D.22537>:
          iftmp.13 = uninflated;
          <D.22538>:
          name = mono_type_full_name (iftmp.13);
          {
            struct MonoVerifyInfoExtended * vinfo;

            vinfo = monoeg_malloc (12);
            vinfo->info.status = 1;
            D.22539 = monoeg_g_strdup_printf ("Invalid local %d of type %s", i, name);
            vinfo->info.message = D.22539;
            vinfo->exception_type = 3;
            D.22431 = ctx.list;
            D.22540 = monoeg_g_slist_prepend (D.22431, vinfo);
            ctx.list = D.22540;
          }
          ctx.valid = 0;
          monoeg_g_free (name);
          mono_error_cleanup (&error);
          ctx.num_locals = i;
          ctx.max_args = 0;
          goto cleanup;
        }
        <D.22534>:
      }
      i = i + 1;
      <D.21622>:
      D.22473 = ctx.num_locals;
      if (D.22473 > i) goto <D.21621>; else goto <D.21623>;
      <D.21623>:
      i = 0;
      goto <D.21628>;
      <D.21627>:
      {
        struct MonoType * uninflated;

        D.22499 = ctx.params;
        i.12 = (unsigned int) i;
        D.22527 = i.12 * 4;
        D.22541 = D.22499 + D.22527;
        uninflated = *D.22541;
        D.22499 = ctx.params;
        i.12 = (unsigned int) i;
        D.22527 = i.12 * 4;
        D.22541 = D.22499 + D.22527;
        D.22499 = ctx.params;
        i.12 = (unsigned int) i;
        D.22527 = i.12 * 4;
        D.22541 = D.22499 + D.22527;
        D.22542 = *D.22541;
        D.22530 = ctx.generic_context;
        D.22543 = mono_class_inflate_generic_type_checked (D.22542, D.22530, &error);
        *D.22541 = D.22543;
        D.22544 = mono_error_ok (&error);
        if (D.22544 == 0) goto <D.22545>; else goto <D.22546>;
        <D.22545>:
        {
          char * name;

          D.22499 = ctx.params;
          i.12 = (unsigned int) i;
          D.22527 = i.12 * 4;
          D.22541 = D.22499 + D.22527;
          D.22542 = *D.22541;
          if (D.22542 != 0B) goto <D.22548>; else goto <D.22549>;
          <D.22548>:
          D.22499 = ctx.params;
          i.12 = (unsigned int) i;
          D.22527 = i.12 * 4;
          D.22541 = D.22499 + D.22527;
          iftmp.14 = *D.22541;
          goto <D.22550>;
          <D.22549>:
          iftmp.14 = uninflated;
          <D.22550>:
          name = mono_type_full_name (iftmp.14);
          {
            struct MonoVerifyInfoExtended * vinfo;

            vinfo = monoeg_malloc (12);
            vinfo->info.status = 1;
            D.22551 = monoeg_g_strdup_printf ("Invalid parameter %d of type %s", i, name);
            vinfo->info.message = D.22551;
            vinfo->exception_type = 3;
            D.22431 = ctx.list;
            D.22552 = monoeg_g_slist_prepend (D.22431, vinfo);
            ctx.list = D.22552;
          }
          ctx.valid = 0;
          monoeg_g_free (name);
          mono_error_cleanup (&error);
          ctx.max_args = i;
          goto cleanup;
        }
        <D.22546>:
      }
      i = i + 1;
      <D.21628>:
      D.22491 = ctx.max_args;
      if (D.22491 > i) goto <D.21627>; else goto <D.21629>;
      <D.21629>:
      stack_init (&ctx, &ctx.eval);
      i = 0;
      goto <D.21634>;
      <D.21633>:
      D.22525 = ctx.locals;
      i.12 = (unsigned int) i;
      D.22527 = i.12 * 4;
      D.22528 = D.22525 + D.22527;
      D.22529 = *D.22528;
      D.22553 = mono_type_is_valid_in_context (&ctx, D.22529);
      if (D.22553 == 0) goto <D.21630>; else goto <D.22554>;
      <D.22554>:
      D.22525 = ctx.locals;
      i.12 = (unsigned int) i;
      D.22527 = i.12 * 4;
      D.22528 = D.22525 + D.22527;
      D.22529 = *D.22528;
      D.22555 = get_stack_type (D.22529);
      if (D.22555 == 0) goto <D.22556>; else goto <D.22557>;
      <D.22556>:
      {
        char * name;

        D.22525 = ctx.locals;
        i.12 = (unsigned int) i;
        D.22527 = i.12 * 4;
        D.22528 = D.22525 + D.22527;
        D.22529 = *D.22528;
        name = mono_type_full_name (D.22529);
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22558 = monoeg_g_strdup_printf ("Invalid local %i of type %s", i, name);
          vinfo->info.message = D.22558;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22559 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22559;
        }
        ctx.valid = 0;
        monoeg_g_free (name);
        goto <D.21630>;
      }
      <D.22557>:
      i = i + 1;
      <D.21634>:
      D.22473 = ctx.num_locals;
      if (D.22473 > i) goto <D.21633>; else goto <D.21630>;
      <D.21630>:
      i = 0;
      goto <D.21639>;
      <D.21638>:
      D.22499 = ctx.params;
      i.12 = (unsigned int) i;
      D.22527 = i.12 * 4;
      D.22541 = D.22499 + D.22527;
      D.22542 = *D.22541;
      D.22560 = mono_type_is_valid_in_context (&ctx, D.22542);
      if (D.22560 == 0) goto <D.21635>; else goto <D.22561>;
      <D.22561>:
      D.22499 = ctx.params;
      i.12 = (unsigned int) i;
      D.22527 = i.12 * 4;
      D.22541 = D.22499 + D.22527;
      D.22542 = *D.22541;
      D.22562 = get_stack_type (D.22542);
      if (D.22562 == 0) goto <D.22563>; else goto <D.22564>;
      <D.22563>:
      {
        char * name;

        D.22499 = ctx.params;
        i.12 = (unsigned int) i;
        D.22527 = i.12 * 4;
        D.22541 = D.22499 + D.22527;
        D.22542 = *D.22541;
        name = mono_type_full_name (D.22542);
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22565 = monoeg_g_strdup_printf ("Invalid parameter %i of type %s", i, name);
          vinfo->info.message = D.22565;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22566 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22566;
        }
        ctx.valid = 0;
        monoeg_g_free (name);
        goto <D.21635>;
      }
      <D.22564>:
      i = i + 1;
      <D.21639>:
      D.22491 = ctx.max_args;
      if (D.22491 > i) goto <D.21638>; else goto <D.21635>;
      <D.21635>:
      D.22462 = ctx.valid;
      if (D.22462 == 0) goto cleanup; else goto <D.22567>;
      <D.22567>:
      i = 0;
      goto <D.21654>;
      <D.21653>:
      {
        struct MonoExceptionClause * clause;

        D.22449 = ctx.header;
        D.22568 = D.22449->clauses;
        i.12 = (unsigned int) i;
        D.22569 = i.12 * 24;
        clause = D.22568 + D.22569;
        D.22572 = clause->try_offset;
        D.22573 = ctx.code_size;
        D.22574 = (unsigned int) D.22573;
        if (D.22572 > D.22574) goto <D.22570>; else goto <D.22575>;
        <D.22575>:
        D.22572 = clause->try_offset;
        D.22576 = clause->try_len;
        D.22577 = D.22572 + D.22576;
        D.22573 = ctx.code_size;
        D.22574 = (unsigned int) D.22573;
        if (D.22577 > D.22574) goto <D.22570>; else goto <D.22578>;
        <D.22578>:
        D.22576 = clause->try_len;
        D.22579 = ~D.22576;
        D.22572 = clause->try_offset;
        if (D.22579 < D.22572) goto <D.22570>; else goto <D.22571>;
        <D.22570>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22572 = clause->try_offset;
          D.22580 = monoeg_g_strdup_printf ("try clause out of bounds at 0x%04x", D.22572);
          vinfo->info.message = D.22580;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22581 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22581;
        }
        ctx.valid = 0;
        <D.22571>:
        D.22576 = clause->try_len;
        if (D.22576 == 0) goto <D.22582>; else goto <D.22583>;
        <D.22582>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22572 = clause->try_offset;
          D.22584 = monoeg_g_strdup_printf ("try clause len <= 0 at 0x%04x", D.22572);
          vinfo->info.message = D.22584;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22585 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22585;
        }
        ctx.valid = 0;
        <D.22583>:
        D.22588 = clause->handler_offset;
        D.22573 = ctx.code_size;
        D.22574 = (unsigned int) D.22573;
        if (D.22588 > D.22574) goto <D.22586>; else goto <D.22589>;
        <D.22589>:
        D.22588 = clause->handler_offset;
        D.22590 = clause->handler_len;
        D.22591 = D.22588 + D.22590;
        D.22573 = ctx.code_size;
        D.22574 = (unsigned int) D.22573;
        if (D.22591 > D.22574) goto <D.22586>; else goto <D.22592>;
        <D.22592>:
        D.22590 = clause->handler_len;
        D.22593 = ~D.22590;
        D.22588 = clause->handler_offset;
        if (D.22593 < D.22588) goto <D.22586>; else goto <D.22587>;
        <D.22586>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22572 = clause->try_offset;
          D.22594 = monoeg_g_strdup_printf ("handler clause out of bounds at 0x%04x", D.22572);
          vinfo->info.message = D.22594;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22595 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22595;
        }
        ctx.valid = 0;
        <D.22587>:
        D.22590 = clause->handler_len;
        if (D.22590 == 0) goto <D.22596>; else goto <D.22597>;
        <D.22596>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22572 = clause->try_offset;
          D.22598 = monoeg_g_strdup_printf ("handler clause len <= 0 at 0x%04x", D.22572);
          vinfo->info.message = D.22598;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22599 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22599;
        }
        ctx.valid = 0;
        <D.22597>:
        D.22572 = clause->try_offset;
        D.22588 = clause->handler_offset;
        if (D.22572 < D.22588) goto <D.22602>; else goto <D.22603>;
        <D.22602>:
        D.22572 = clause->try_offset;
        D.22576 = clause->try_len;
        D.22577 = D.22572 + D.22576;
        D.22605 = clause->flags;
        if (D.22605 == 1) goto <D.22606>; else goto <D.22607>;
        <D.22606>:
        iftmp.15 = clause->data.filter_offset;
        goto <D.22608>;
        <D.22607>:
        iftmp.15 = clause->handler_offset;
        <D.22608>:
        if (D.22577 > iftmp.15) goto <D.22600>; else goto <D.22609>;
        <D.22609>:
        D.22576 = clause->try_len;
        D.22579 = ~D.22576;
        D.22572 = clause->try_offset;
        if (D.22579 < D.22572) goto <D.22600>; else goto <D.22601>;
        <D.22600>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22572 = clause->try_offset;
          D.22588 = clause->handler_offset;
          D.22610 = monoeg_g_strdup_printf ("try block (at 0x%04x) includes handler block (at 0x%04x)", D.22572, D.22588);
          vinfo->info.message = D.22610;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22611 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22611;
        }
        ctx.valid = 0;
        <D.22601>:
        <D.22603>:
        D.22605 = clause->flags;
        if (D.22605 == 1) goto <D.22612>; else goto <D.22613>;
        <D.22612>:
        D.22614 = clause->data.filter_offset;
        D.22573 = ctx.code_size;
        D.22574 = (unsigned int) D.22573;
        if (D.22614 > D.22574) goto <D.22615>; else goto <D.22616>;
        <D.22615>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22572 = clause->try_offset;
          D.22617 = monoeg_g_strdup_printf ("filter clause out of bounds at 0x%04x", D.22572);
          vinfo->info.message = D.22617;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22618 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22618;
        }
        ctx.valid = 0;
        <D.22616>:
        D.22614 = clause->data.filter_offset;
        D.22588 = clause->handler_offset;
        if (D.22614 >= D.22588) goto <D.22619>; else goto <D.22620>;
        <D.22619>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22614 = clause->data.filter_offset;
          D.22621 = monoeg_g_strdup_printf ("filter clause must come before the handler clause at 0x%04x", D.22614);
          vinfo->info.message = D.22621;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22622 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22622;
        }
        ctx.valid = 0;
        <D.22620>:
        <D.22613>:
        n = i + 1;
        goto <D.21649>;
        <D.21648>:
        D.22449 = ctx.header;
        D.22568 = D.22449->clauses;
        n.16 = (unsigned int) n;
        D.22624 = n.16 * 24;
        D.22625 = D.22568 + D.22624;
        verify_clause_relationship (&ctx, clause, D.22625);
        n = n + 1;
        <D.21649>:
        D.22449 = ctx.header;
        D.22626 = D.22449->num_clauses;
        D.22627 = (int) D.22626;
        if (D.22627 > n) goto <D.22628>; else goto <D.21650>;
        <D.22628>:
        D.22462 = ctx.valid;
        if (D.22462 != 0) goto <D.21648>; else goto <D.21650>;
        <D.21650>:
        D.22462 = ctx.valid;
        if (D.22462 == 0) goto <D.21651>; else goto <D.22629>;
        <D.22629>:
        D.22466 = ctx.code;
        D.22572 = clause->try_offset;
        D.22630 = D.22572 * 12;
        D.22631 = D.22466 + D.22630;
        D.22466 = ctx.code;
        D.22572 = clause->try_offset;
        D.22630 = D.22572 * 12;
        D.22631 = D.22466 + D.22630;
        D.22632 = D.22631->flags;
        D.22633 = D.22632 | 2;
        D.22631->flags = D.22633;
        D.22572 = clause->try_offset;
        D.22576 = clause->try_len;
        D.22577 = D.22572 + D.22576;
        D.22573 = ctx.code_size;
        D.22574 = (unsigned int) D.22573;
        if (D.22577 < D.22574) goto <D.22634>; else goto <D.22635>;
        <D.22634>:
        D.22466 = ctx.code;
        D.22572 = clause->try_offset;
        D.22576 = clause->try_len;
        D.22577 = D.22572 + D.22576;
        D.22636 = D.22577 * 12;
        D.22637 = D.22466 + D.22636;
        D.22466 = ctx.code;
        D.22572 = clause->try_offset;
        D.22576 = clause->try_len;
        D.22577 = D.22572 + D.22576;
        D.22636 = D.22577 * 12;
        D.22637 = D.22466 + D.22636;
        D.22638 = D.22637->flags;
        D.22639 = D.22638 | 2;
        D.22637->flags = D.22639;
        <D.22635>:
        D.22588 = clause->handler_offset;
        D.22590 = clause->handler_len;
        D.22591 = D.22588 + D.22590;
        D.22573 = ctx.code_size;
        D.22574 = (unsigned int) D.22573;
        if (D.22591 < D.22574) goto <D.22640>; else goto <D.22641>;
        <D.22640>:
        D.22466 = ctx.code;
        D.22588 = clause->handler_offset;
        D.22590 = clause->handler_len;
        D.22591 = D.22588 + D.22590;
        D.22642 = D.22591 * 12;
        D.22643 = D.22466 + D.22642;
        D.22466 = ctx.code;
        D.22588 = clause->handler_offset;
        D.22590 = clause->handler_len;
        D.22591 = D.22588 + D.22590;
        D.22642 = D.22591 * 12;
        D.22643 = D.22466 + D.22642;
        D.22644 = D.22643->flags;
        D.22645 = D.22644 | 2;
        D.22643->flags = D.22645;
        <D.22641>:
        D.22605 = clause->flags;
        if (D.22605 == 0) goto <D.22646>; else goto <D.22647>;
        <D.22646>:
        D.22648 = clause->data.catch_class;
        if (D.22648 == 0B) goto <D.22649>; else goto <D.22650>;
        <D.22649>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22651 = monoeg_g_strdup_printf ("Catch clause %d with invalid type", i);
          vinfo->info.message = D.22651;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22652 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22652;
        }
        ctx.valid = 0;
        goto <D.21651>;
        <D.22650>:
        D.22648 = clause->data.catch_class;
        D.22653 = &D.22648->byval_arg;
        D.22654 = mono_type_is_valid_in_context (&ctx, D.22653);
        if (D.22654 == 0) goto <D.21651>; else goto <D.22655>;
        <D.22655>:
        D.22466 = ctx.code;
        D.22588 = clause->handler_offset;
        D.22656 = D.22588 * 12;
        D.22657 = D.22466 + D.22656;
        D.22648 = clause->data.catch_class;
        init_stack_with_value_at_exception_boundary (&ctx, D.22657, D.22648);
        goto <D.22658>;
        <D.22647>:
        D.22605 = clause->flags;
        if (D.22605 == 1) goto <D.22659>; else goto <D.22660>;
        <D.22659>:
        D.22466 = ctx.code;
        D.22614 = clause->data.filter_offset;
        D.22661 = D.22614 * 12;
        D.22662 = D.22466 + D.22661;
        D.22663 = mono_defaults.exception_class;
        init_stack_with_value_at_exception_boundary (&ctx, D.22662, D.22663);
        D.22466 = ctx.code;
        D.22588 = clause->handler_offset;
        D.22656 = D.22588 * 12;
        D.22657 = D.22466 + D.22656;
        D.22663 = mono_defaults.exception_class;
        init_stack_with_value_at_exception_boundary (&ctx, D.22657, D.22663);
        <D.22660>:
        <D.22658>:
      }
      i = i + 1;
      <D.21654>:
      D.22449 = ctx.header;
      D.22626 = D.22449->num_clauses;
      D.22627 = (int) D.22626;
      if (D.22627 > i) goto <D.22664>; else goto <D.21651>;
      <D.22664>:
      D.22462 = ctx.valid;
      if (D.22462 != 0) goto <D.21653>; else goto <D.21651>;
      <D.21651>:
      D.22462 = ctx.valid;
      if (D.22462 == 0) goto cleanup; else goto <D.22665>;
      <D.22665>:
      bb = mono_basic_block_split (method, &error);
      original_bb = bb;
      D.22666 = mono_error_ok (&error);
      if (D.22666 == 0) goto <D.22667>; else goto <D.22668>;
      <D.22667>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22669 = mono_error_get_message (&error);
        D.22670 = monoeg_g_strdup_printf ("Invalid branch target: %s", D.22669);
        vinfo->info.message = D.22670;
        vinfo->exception_type = 3;
        D.22431 = ctx.list;
        D.22671 = monoeg_g_slist_prepend (D.22431, vinfo);
        ctx.list = D.22671;
      }
      ctx.valid = 0;
      mono_error_cleanup (&error);
      goto cleanup;
      <D.22668>:
      D.22672 = bb == 0B;
      D.22673 = (long int) D.22672;
      D.22674 = __builtin_expect (D.22673, 0);
      if (D.22674 != 0) goto <D.22675>; else goto <D.22676>;
      <D.22675>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "verify.c", 5001, "bb");
      <D.22676>:
      goto <D.21673>;
      <D.21983>:
      {
        int op_size;

        ip.17 = (int) ip;
        code_start.18 = (int) code_start;
        D.22679 = ip.17 - code_start.18;
        ip_offset = (guint) D.22679;
        {
          const unsigned char * ip_copy;
          int op;

          try
            {
              ip_copy = ip;
              D.22680 = bb->end;
              D.22681 = (unsigned int) D.22680;
              if (D.22681 < ip_offset) goto <D.22682>; else goto <D.22683>;
              <D.22682>:
              {
                struct MonoVerifyInfoExtended * vinfo;

                vinfo = monoeg_malloc (12);
                vinfo->info.status = 1;
                D.22680 = bb->end;
                D.22684 = monoeg_g_strdup_printf ("Branch or EH block at [0x%04x] targets middle instruction at 0x%04x", D.22680, ip_offset);
                vinfo->info.message = D.22684;
                vinfo->exception_type = 3;
                D.22431 = ctx.list;
                D.22685 = monoeg_g_slist_prepend (D.22431, vinfo);
                ctx.list = D.22685;
              }
              ctx.valid = 0;
              goto cleanup;
              <D.22683>:
              D.22680 = bb->end;
              D.22681 = (unsigned int) D.22680;
              if (D.22681 == ip_offset) goto <D.22686>; else goto <D.22687>;
              <D.22686>:
              bb = bb->next;
              <D.22687>:
              op_size = mono_opcode_value_and_size (&ip_copy, end, &op);
              if (op_size == -1) goto <D.22688>; else goto <D.22689>;
              <D.22688>:
              {
                struct MonoVerifyInfoExtended * vinfo;

                vinfo = monoeg_malloc (12);
                vinfo->info.status = 1;
                D.22690 = *ip;
                D.22691 = (int) D.22690;
                D.22692 = monoeg_g_strdup_printf ("Invalid instruction %x at 0x%04x", D.22691, ip_offset);
                vinfo->info.message = D.22692;
                vinfo->exception_type = 3;
                D.22431 = ctx.list;
                D.22693 = monoeg_g_slist_prepend (D.22431, vinfo);
                ctx.list = D.22693;
              }
              ctx.valid = 0;
              goto cleanup;
              <D.22689>:
              op_size.19 = (unsigned int) op_size;
              D.22697 = ip_offset + op_size.19;
              D.22680 = bb->end;
              D.22681 = (unsigned int) D.22680;
              if (D.22697 > D.22681) goto <D.22694>; else goto <D.22698>;
              <D.22698>:
              op_size.20 = (unsigned int) op_size;
              D.22700 = ~op_size.20;
              if (D.22700 < ip_offset) goto <D.22694>; else goto <D.22695>;
              <D.22694>:
              {
                struct MonoVerifyInfoExtended * vinfo;

                vinfo = monoeg_malloc (12);
                vinfo->info.status = 1;
                D.22701 = monoeg_g_strdup_printf ("Branch or EH block targets middle of instruction at 0x%04x", ip_offset);
                vinfo->info.message = D.22701;
                vinfo->exception_type = 3;
                D.22431 = ctx.list;
                D.22702 = monoeg_g_slist_prepend (D.22431, vinfo);
                ctx.list = D.22702;
              }
              ctx.valid = 0;
              goto cleanup;
              <D.22695>:
              op_size.19 = (unsigned int) op_size;
              D.22697 = ip_offset + op_size.19;
              D.22680 = bb->end;
              D.22681 = (unsigned int) D.22680;
              if (D.22697 == D.22681) goto <D.22703>; else goto <D.22704>;
              <D.22703>:
              op.21 = op;
              D.22706 = mono_opcode_is_prefix (op.21);
              if (D.22706 != 0) goto <D.22707>; else goto <D.22708>;
              <D.22707>:
              {
                struct MonoVerifyInfoExtended * vinfo;

                vinfo = monoeg_malloc (12);
                vinfo->info.status = 1;
                op.21 = op;
                D.22709 = mono_opcode_name (op.21);
                D.22710 = monoeg_g_strdup_printf ("Branch or EH block targets between prefix \'%s\' and instruction at 0x%04x", D.22709, ip_offset);
                vinfo->info.message = D.22710;
                vinfo->exception_type = 3;
                D.22431 = ctx.list;
                D.22711 = monoeg_g_slist_prepend (D.22431, vinfo);
                ctx.list = D.22711;
              }
              ctx.valid = 0;
              goto cleanup;
              <D.22708>:
              <D.22704>:
            }
          finally
            {
              ip_copy = {CLOBBER};
              op = {CLOBBER};
            }
        }
        ip.17 = (int) ip;
        code_start.18 = (int) code_start;
        D.22679 = ip.17 - code_start.18;
        ip_offset = (guint) D.22679;
        ctx.ip_offset = ip_offset;
        i = 0;
        goto <D.21671>;
        <D.21670>:
        {
          struct MonoExceptionClause * clause;

          D.22449 = ctx.header;
          D.22568 = D.22449->clauses;
          i.12 = (unsigned int) i;
          D.22569 = i.12 * 24;
          clause = D.22568 + D.22569;
          D.22712 = clause->try_offset;
          D.22713 = clause->try_len;
          D.22714 = D.22712 + D.22713;
          if (D.22714 == ip_offset) goto <D.22715>; else goto <D.22716>;
          <D.22715>:
          if (start == 0) goto <D.22717>; else goto <D.22718>;
          <D.22717>:
          D.22482 = ctx.verifiable;
          if (D.22482 != 0) goto <D.22719>; else goto <D.22721>;
          <D.22721>:
          D.22484 = ctx.level;
          D.22485 = D.22484 & 128;
          if (D.22485 != 0) goto <D.22719>; else goto <D.22720>;
          <D.22719>:
          {
            struct MonoVerifyInfoExtended * vinfo;

            vinfo = monoeg_malloc (12);
            vinfo->info.status = 8;
            D.22722 = monoeg_g_strdup_printf ("fallthru off try block at 0x%04x", ip_offset);
            vinfo->info.message = D.22722;
            vinfo->exception_type = 4;
            D.22431 = ctx.list;
            D.22723 = monoeg_g_slist_prepend (D.22431, vinfo);
            ctx.list = D.22723;
          }
          ctx.verifiable = 0;
          D.22484 = ctx.level;
          D.22488 = D.22484 & 16;
          if (D.22488 != 0) goto <D.22724>; else goto <D.22725>;
          <D.22724>:
          ctx.valid = 0;
          <D.22725>:
          <D.22720>:
          start = 1;
          <D.22718>:
          <D.22716>:
          D.22726 = clause->handler_offset;
          D.22727 = clause->handler_len;
          D.22728 = D.22726 + D.22727;
          if (D.22728 == ip_offset) goto <D.22729>; else goto <D.22730>;
          <D.22729>:
          if (start == 0) goto <D.22731>; else goto <D.22732>;
          <D.22731>:
          D.22733 = clause->flags;
          if (D.22733 == 1) goto <D.22734>; else goto <D.22735>;
          <D.22734>:
          {
            struct MonoVerifyInfoExtended * vinfo;

            vinfo = monoeg_malloc (12);
            vinfo->info.status = 1;
            D.22736 = monoeg_g_strdup_printf ("fallout of handler block at 0x%04x", ip_offset);
            vinfo->info.message = D.22736;
            vinfo->exception_type = 3;
            D.22431 = ctx.list;
            D.22737 = monoeg_g_slist_prepend (D.22431, vinfo);
            ctx.list = D.22737;
          }
          ctx.valid = 0;
          goto <D.22738>;
          <D.22735>:
          D.22482 = ctx.verifiable;
          if (D.22482 != 0) goto <D.22739>; else goto <D.22741>;
          <D.22741>:
          D.22484 = ctx.level;
          D.22485 = D.22484 & 128;
          if (D.22485 != 0) goto <D.22739>; else goto <D.22740>;
          <D.22739>:
          {
            struct MonoVerifyInfoExtended * vinfo;

            vinfo = monoeg_malloc (12);
            vinfo->info.status = 8;
            D.22742 = monoeg_g_strdup_printf ("fallout of handler block at 0x%04x", ip_offset);
            vinfo->info.message = D.22742;
            vinfo->exception_type = 4;
            D.22431 = ctx.list;
            D.22743 = monoeg_g_slist_prepend (D.22431, vinfo);
            ctx.list = D.22743;
          }
          ctx.verifiable = 0;
          D.22484 = ctx.level;
          D.22488 = D.22484 & 16;
          if (D.22488 != 0) goto <D.22744>; else goto <D.22745>;
          <D.22744>:
          ctx.valid = 0;
          <D.22745>:
          <D.22740>:
          <D.22738>:
          start = 1;
          <D.22732>:
          <D.22730>:
          D.22733 = clause->flags;
          if (D.22733 == 1) goto <D.22746>; else goto <D.22747>;
          <D.22746>:
          D.22726 = clause->handler_offset;
          if (D.22726 == ip_offset) goto <D.22748>; else goto <D.22749>;
          <D.22748>:
          if (start == 0) goto <D.22750>; else goto <D.22751>;
          <D.22750>:
          {
            struct MonoVerifyInfoExtended * vinfo;

            vinfo = monoeg_malloc (12);
            vinfo->info.status = 1;
            D.22752 = monoeg_g_strdup_printf ("fallout of filter block at 0x%04x", ip_offset);
            vinfo->info.message = D.22752;
            vinfo->exception_type = 3;
            D.22431 = ctx.list;
            D.22753 = monoeg_g_slist_prepend (D.22431, vinfo);
            ctx.list = D.22753;
          }
          ctx.valid = 0;
          start = 1;
          <D.22751>:
          <D.22749>:
          <D.22747>:
          D.22726 = clause->handler_offset;
          if (D.22726 == ip_offset) goto <D.22754>; else goto <D.22755>;
          <D.22754>:
          if (start == 0) goto <D.22756>; else goto <D.22757>;
          <D.22756>:
          D.22482 = ctx.verifiable;
          if (D.22482 != 0) goto <D.22758>; else goto <D.22760>;
          <D.22760>:
          D.22484 = ctx.level;
          D.22485 = D.22484 & 128;
          if (D.22485 != 0) goto <D.22758>; else goto <D.22759>;
          <D.22758>:
          {
            struct MonoVerifyInfoExtended * vinfo;

            vinfo = monoeg_malloc (12);
            vinfo->info.status = 8;
            D.22761 = monoeg_g_strdup_printf ("fallthru handler block at 0x%04x", ip_offset);
            vinfo->info.message = D.22761;
            vinfo->exception_type = 4;
            D.22431 = ctx.list;
            D.22762 = monoeg_g_slist_prepend (D.22431, vinfo);
            ctx.list = D.22762;
          }
          ctx.verifiable = 0;
          D.22484 = ctx.level;
          D.22488 = D.22484 & 16;
          if (D.22488 != 0) goto <D.22763>; else goto <D.22764>;
          <D.22763>:
          ctx.valid = 0;
          <D.22764>:
          <D.22759>:
          start = 1;
          <D.22757>:
          <D.22755>:
          D.22712 = clause->try_offset;
          if (D.22712 == ip_offset) goto <D.22765>; else goto <D.22766>;
          <D.22765>:
          D.22767 = ctx.eval.size;
          if (D.22767 != 0) goto <D.22768>; else goto <D.22769>;
          <D.22768>:
          if (start == 0) goto <D.22770>; else goto <D.22771>;
          <D.22770>:
          {
            struct MonoVerifyInfoExtended * vinfo;

            vinfo = monoeg_malloc (12);
            vinfo->info.status = 1;
            D.22772 = monoeg_g_strdup_printf ("Try to enter try block with a non-empty stack at 0x%04x", ip_offset);
            vinfo->info.message = D.22772;
            vinfo->exception_type = 3;
            D.22431 = ctx.list;
            D.22773 = monoeg_g_slist_prepend (D.22431, vinfo);
            ctx.list = D.22773;
          }
          ctx.valid = 0;
          start = 1;
          <D.22771>:
          <D.22769>:
          <D.22766>:
        }
        i = i + 1;
        <D.21671>:
        D.22449 = ctx.header;
        D.22626 = D.22449->num_clauses;
        D.22627 = (int) D.22626;
        if (D.22627 > i) goto <D.22774>; else goto <D.21672>;
        <D.22774>:
        D.22462 = ctx.valid;
        if (D.22462 != 0) goto <D.21670>; else goto <D.21672>;
        <D.21672>:
        D.22775 = BIT_FIELD_REF <*bb, 8, 224>;
        D.22776 = D.22775 & 2;
        if (D.22776 != 0) goto <D.22777>; else goto <D.22778>;
        <D.22777>:
        D.22466 = ctx.code;
        D.22779 = ip_offset * 12;
        D.22780 = D.22466 + D.22779;
        D.22466 = ctx.code;
        D.22779 = ip_offset * 12;
        D.22780 = D.22466 + D.22779;
        D.22781 = D.22780->flags;
        D.22782 = D.22781 | 1;
        D.22780->flags = D.22782;
        op_size.22 = (sizetype) op_size;
        ip = ip + op_size.22;
        // predicted unlikely by continue predictor.
        goto <D.21673>;
        <D.22778>:
        D.22462 = ctx.valid;
        if (D.22462 == 0) goto <D.21674>; else goto <D.22784>;
        <D.22784>:
        if (need_merge != 0) goto <D.22785>; else goto <D.22786>;
        <D.22785>:
        D.22466 = ctx.code;
        D.22787 = ctx.target;
        D.22788 = (unsigned int) D.22787;
        D.22789 = D.22788 * 12;
        D.22790 = D.22466 + D.22789;
        merge_stacks (&ctx, &ctx.eval, D.22790, 0, 1);
        need_merge = 0;
        <D.22786>:
        D.22466 = ctx.code;
        D.22779 = ip_offset * 12;
        D.22780 = D.22466 + D.22779;
        merge_stacks (&ctx, &ctx.eval, D.22780, start, 0);
        start = 0;
        D.22690 = *ip;
        D.22691 = (int) D.22690;
        switch (D.22691) <default: <D.21977>, case 0: <D.21675>, case 1: <D.21676>, case 2: <D.21678>, case 3: <D.21679>, case 4: <D.21680>, case 5: <D.21681>, case 6: <D.21706>, case 7: <D.21707>, case 8: <D.21708>, case 9: <D.21709>, case 10: <D.21710>, case 11: <D.21711>, case 12: <D.21712>, case 13: <D.21713>, case 14: <D.21682>, case 15: <D.21683>, case 16: <D.21716>, case 17: <D.21763>, case 18: <D.21764>, case 19: <D.21714>, case 20: <D.21738>, case 21: <D.21718>, case 22: <D.21719>, case 23: <D.21720>, case 24: <D.21721>, case 25: <D.21722>, case 26: <D.21723>, case 27: <D.21724>, case 28: <D.21725>, case 29: <D.21726>, case 30: <D.21727>, case 31: <D.21728>, case 32: <D.21730>, case 33: <D.21732>, case 34: <D.21734>, case 35: <D.21736>, case 36: <D.21766>, case 37: <D.21768>, case 38: <D.21704>, case 39: <D.21770>, case 40: <D.21775>, case 41: <D.21778>, case 42: <D.21705>, case 43: <D.21781>, case 44: <D.21783>, case 45: <D.21784>, case 46: <D.21739>, case 47: <D.21742>, case 48: <D.21743>, case 49: <D.21744>, case 50: <D.21745>, case 51: <D.21740>, case 52: <D.21746>, case 53: <D.21747>, case 54: <D.21748>, case 55: <D.21749>, case 56: <D.21786>, case 57: <D.21788>, case 58: <D.21789>, case 59: <D.21751>, case 60: <D.21754>, case 61: <D.21755>, case 62: <D.21756>, case 63: <D.21757>, case 64: <D.21752>, case 65: <D.21758>, case 66: <D.21759>, case 67: <D.21760>, case 68: <D.21761>, case 69: <D.21791>, case 70: <D.21796>, case 71: <D.21797>, case 72: <D.21798>, case 73: <D.21799>, case 74: <D.21800>, case 75: <D.21801>, case 76: <D.21802>, case 77: <D.21803>, case 78: <D.21804>, case 79: <D.21805>, case 80: <D.21806>, case 81: <D.21807>, case 82: <D.21808>, case 83: <D.21809>, case 84: <D.21810>, case 85: <D.21811>, case 86: <D.21812>, case 87: <D.21813>, case 88: <D.21691>, case 89: <D.21692>, case 90: <D.21693>, case 91: <D.21694>, case 92: <D.21697>, case 93: <D.21695>, case 94: <D.21699>, case 95: <D.21696>, case 96: <D.21698>, case 97: <D.21700>, case 98: <D.21701>, case 99: <D.21702>, case 100: <D.21703>, case 101: <D.21816>, case 102: <D.21815>, case 103: <D.21817>, case 104: <D.21818>, case 105: <D.21819>, case 106: <D.21823>, case 107: <D.21825>, case 108: <D.21826>, case 109: <D.21822>, case 110: <D.21824>, case 111: <D.21776>, case 112: <D.21830>, case 113: <D.21832>, case 114: <D.21834>, case 115: <D.21836>, case 116: <D.21838>, case 117: <D.21839>, case 118: <D.21827>, case 119: <D.21841>, case 120: <D.21842>, case 121: <D.21844>, case 122: <D.21846>, case 123: <D.21847>, case 124: <D.21848>, case 125: <D.21853>, case 126: <D.21850>, case 127: <D.21851>, case 128: <D.21855>, case 129: <D.21857>, case 130: <D.21859>, case 131: <D.21860>, case 132: <D.21861>, case 133: <D.21865>, case 134: <D.21862>, case 135: <D.21863>, case 136: <D.21864>, case 137: <D.21866>, case 138: <D.21867>, case 139: <D.21868>, case 140: <D.21869>, case 141: <D.21871>, case 142: <D.21873>, case 143: <D.21874>, case 144: <D.21876>, case 145: <D.21877>, case 146: <D.21878>, case 147: <D.21879>, case 148: <D.21880>, case 149: <D.21881>, case 150: <D.21882>, case 151: <D.21883>, case 152: <D.21884>, case 153: <D.21885>, case 154: <D.21886>, case 155: <D.21887>, case 156: <D.21888>, case 157: <D.21889>, case 158: <D.21890>, case 159: <D.21891>, case 160: <D.21892>, case 161: <D.21893>, case 162: <D.21894>, case 163: <D.21895>, case 164: <D.21897>, case 165: <D.21899>, case 179: <D.21901>, case 180: <D.21902>, case 181: <D.21903>, case 182: <D.21904>, case 183: <D.21905>, case 184: <D.21906>, case 185: <D.21907>, case 186: <D.21908>, case 194: <D.21911>, case 195: <D.21913>, case 198: <D.21914>, case 208: <D.21916>, case 209: <D.21821>, case 210: <D.21820>, case 211: <D.21828>, case 212: <D.21909>, case 213: <D.21910>, case 214: <D.21687>, case 215: <D.21685>, case 216: <D.21689>, case 217: <D.21690>, case 218: <D.21688>, case 219: <D.21686>, case 220: <D.21918>, case 221: <D.21920>, case 222: <D.21922>, case 223: <D.21814>, case 224: <D.21829>, case 254: <D.21924>>
        <D.21675>:
        <D.21676>:
        ip = ip + 1;
        goto <D.21677>;
        <D.21678>:
        <D.21679>:
        <D.21680>:
        <D.21681>:
        D.22690 = *ip;
        D.22691 = (int) D.22690;
        D.22791 = D.22691 + -2;
        D.22792 = (unsigned int) D.22791;
        push_arg (&ctx, D.22792, 0);
        ip = ip + 1;
        goto <D.21677>;
        <D.21682>:
        <D.21683>:
        D.22795 = ip + 2;
        if (D.22795 > end) goto <D.22793>; else goto <D.22796>;
        <D.22796>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967293) goto <D.22793>; else goto <D.22794>;
        <D.22793>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22799 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22799;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22800 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22800;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22794>:
        D.22801 = ip + 1;
        D.22802 = *D.22801;
        D.22803 = (unsigned int) D.22802;
        D.22690 = *ip;
        D.22804 = D.22690 == 15;
        D.22805 = (int) D.22804;
        push_arg (&ctx, D.22803, D.22805);
        ip = ip + 2;
        goto <D.21677>;
        <D.21685>:
        D.22690 = *ip;
        D.22806 = (unsigned int) D.22690;
        do_binop (&ctx, D.22806, &add_ovf_un_table);
        ip = ip + 1;
        goto <D.21677>;
        <D.21686>:
        D.22690 = *ip;
        D.22806 = (unsigned int) D.22690;
        do_binop (&ctx, D.22806, &sub_ovf_un_table);
        ip = ip + 1;
        goto <D.21677>;
        <D.21687>:
        <D.21688>:
        <D.21689>:
        <D.21690>:
        D.22690 = *ip;
        D.22806 = (unsigned int) D.22690;
        do_binop (&ctx, D.22806, &bin_ovf_table);
        ip = ip + 1;
        goto <D.21677>;
        <D.21691>:
        D.22690 = *ip;
        D.22806 = (unsigned int) D.22690;
        do_binop (&ctx, D.22806, &add_table);
        ip = ip + 1;
        goto <D.21677>;
        <D.21692>:
        D.22690 = *ip;
        D.22806 = (unsigned int) D.22690;
        do_binop (&ctx, D.22806, &sub_table);
        ip = ip + 1;
        goto <D.21677>;
        <D.21693>:
        <D.21694>:
        <D.21695>:
        D.22690 = *ip;
        D.22806 = (unsigned int) D.22690;
        do_binop (&ctx, D.22806, &bin_op_table);
        ip = ip + 1;
        goto <D.21677>;
        <D.21696>:
        <D.21697>:
        <D.21698>:
        <D.21699>:
        <D.21700>:
        D.22690 = *ip;
        D.22806 = (unsigned int) D.22690;
        do_binop (&ctx, D.22806, &int_bin_op_table);
        ip = ip + 1;
        goto <D.21677>;
        <D.21701>:
        <D.21702>:
        <D.21703>:
        D.22690 = *ip;
        D.22806 = (unsigned int) D.22690;
        do_binop (&ctx, D.22806, &shift_op_table);
        ip = ip + 1;
        goto <D.21677>;
        <D.21704>:
        D.22807 = check_underflow (&ctx, 1);
        if (D.22807 == 0) goto <D.21677>; else goto <D.22808>;
        <D.22808>:
        stack_pop_safe (&ctx);
        ip = ip + 1;
        goto <D.21677>;
        <D.21705>:
        do_ret (&ctx);
        ip = ip + 1;
        start = 1;
        goto <D.21677>;
        <D.21706>:
        <D.21707>:
        <D.21708>:
        <D.21709>:
        D.22690 = *ip;
        D.22691 = (int) D.22690;
        D.22809 = D.22691 + -6;
        D.22810 = (unsigned int) D.22809;
        push_local (&ctx, D.22810, 0);
        ip = ip + 1;
        goto <D.21677>;
        <D.21710>:
        <D.21711>:
        <D.21712>:
        <D.21713>:
        D.22690 = *ip;
        D.22691 = (int) D.22690;
        D.22811 = D.22691 + -10;
        D.22812 = (unsigned int) D.22811;
        store_local (&ctx, D.22812);
        ip = ip + 1;
        goto <D.21677>;
        <D.21714>:
        D.22795 = ip + 2;
        if (D.22795 > end) goto <D.22813>; else goto <D.22815>;
        <D.22815>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967293) goto <D.22813>; else goto <D.22814>;
        <D.22813>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22816 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22816;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22817 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22817;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22814>:
        D.22801 = ip + 1;
        D.22802 = *D.22801;
        D.22818 = (unsigned int) D.22802;
        store_local (&ctx, D.22818);
        ip = ip + 2;
        goto <D.21677>;
        <D.21716>:
        D.22795 = ip + 2;
        if (D.22795 > end) goto <D.22819>; else goto <D.22821>;
        <D.22821>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967293) goto <D.22819>; else goto <D.22820>;
        <D.22819>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22822 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22822;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22823 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22823;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22820>:
        D.22801 = ip + 1;
        D.22802 = *D.22801;
        D.22818 = (unsigned int) D.22802;
        store_arg (&ctx, D.22818);
        ip = ip + 2;
        goto <D.21677>;
        <D.21718>:
        <D.21719>:
        <D.21720>:
        <D.21721>:
        <D.21722>:
        <D.21723>:
        <D.21724>:
        <D.21725>:
        <D.21726>:
        <D.21727>:
        D.22824 = check_overflow (&ctx);
        if (D.22824 != 0) goto <D.22825>; else goto <D.22826>;
        <D.22825>:
        D.22827 = mono_defaults.int32_class;
        D.22828 = &D.22827->byval_arg;
        stack_push_val (&ctx, 1, D.22828);
        <D.22826>:
        ip = ip + 1;
        goto <D.21677>;
        <D.21728>:
        D.22795 = ip + 2;
        if (D.22795 > end) goto <D.22829>; else goto <D.22831>;
        <D.22831>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967293) goto <D.22829>; else goto <D.22830>;
        <D.22829>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22832 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22832;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22833 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22833;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22830>:
        D.22834 = check_overflow (&ctx);
        if (D.22834 != 0) goto <D.22835>; else goto <D.22836>;
        <D.22835>:
        D.22827 = mono_defaults.int32_class;
        D.22828 = &D.22827->byval_arg;
        stack_push_val (&ctx, 1, D.22828);
        <D.22836>:
        ip = ip + 2;
        goto <D.21677>;
        <D.21730>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.22837>; else goto <D.22840>;
        <D.22840>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.22837>; else goto <D.22838>;
        <D.22837>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22841 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22841;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22842 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22842;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22838>:
        D.22843 = check_overflow (&ctx);
        if (D.22843 != 0) goto <D.22844>; else goto <D.22845>;
        <D.22844>:
        D.22827 = mono_defaults.int32_class;
        D.22828 = &D.22827->byval_arg;
        stack_push_val (&ctx, 1, D.22828);
        <D.22845>:
        ip = ip + 5;
        goto <D.21677>;
        <D.21732>:
        D.22848 = ip + 9;
        if (D.22848 > end) goto <D.22846>; else goto <D.22849>;
        <D.22849>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967286) goto <D.22846>; else goto <D.22847>;
        <D.22846>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22850 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22850;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22851 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22851;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22847>:
        D.22852 = check_overflow (&ctx);
        if (D.22852 != 0) goto <D.22853>; else goto <D.22854>;
        <D.22853>:
        D.22855 = mono_defaults.int64_class;
        D.22856 = &D.22855->byval_arg;
        stack_push_val (&ctx, 2, D.22856);
        <D.22854>:
        ip = ip + 9;
        goto <D.21677>;
        <D.21734>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.22857>; else goto <D.22859>;
        <D.22859>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.22857>; else goto <D.22858>;
        <D.22857>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22860 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22860;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22861 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22861;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22858>:
        D.22862 = check_overflow (&ctx);
        if (D.22862 != 0) goto <D.22863>; else goto <D.22864>;
        <D.22863>:
        D.22865 = mono_defaults.double_class;
        D.22866 = &D.22865->byval_arg;
        stack_push_val (&ctx, 4, D.22866);
        <D.22864>:
        ip = ip + 5;
        goto <D.21677>;
        <D.21736>:
        D.22848 = ip + 9;
        if (D.22848 > end) goto <D.22867>; else goto <D.22869>;
        <D.22869>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967286) goto <D.22867>; else goto <D.22868>;
        <D.22867>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22870 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22870;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22871 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22871;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22868>:
        D.22872 = check_overflow (&ctx);
        if (D.22872 != 0) goto <D.22873>; else goto <D.22874>;
        <D.22873>:
        D.22865 = mono_defaults.double_class;
        D.22866 = &D.22865->byval_arg;
        stack_push_val (&ctx, 4, D.22866);
        <D.22874>:
        ip = ip + 9;
        goto <D.21677>;
        <D.21738>:
        D.22875 = check_overflow (&ctx);
        if (D.22875 != 0) goto <D.22876>; else goto <D.22877>;
        <D.22876>:
        D.22878 = mono_defaults.object_class;
        D.22879 = &D.22878->byval_arg;
        stack_push_val (&ctx, 1030, D.22879);
        <D.22877>:
        ip = ip + 1;
        goto <D.21677>;
        <D.21739>:
        <D.21740>:
        D.22795 = ip + 2;
        if (D.22795 > end) goto <D.22880>; else goto <D.22882>;
        <D.22882>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967293) goto <D.22880>; else goto <D.22881>;
        <D.22880>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22883 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22883;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22884 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22884;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22881>:
        D.22801 = ip + 1;
        D.22802 = *D.22801;
        D.22885 = (signed char) D.22802;
        D.22886 = (int) D.22885;
        D.22887 = D.22886 + 2;
        do_branch_op (&ctx, D.22887, &cmp_br_eq_op);
        ip = ip + 2;
        need_merge = 1;
        goto <D.21677>;
        <D.21742>:
        <D.21743>:
        <D.21744>:
        <D.21745>:
        <D.21746>:
        <D.21747>:
        <D.21748>:
        <D.21749>:
        D.22795 = ip + 2;
        if (D.22795 > end) goto <D.22888>; else goto <D.22890>;
        <D.22890>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967293) goto <D.22888>; else goto <D.22889>;
        <D.22888>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22891 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22891;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22892 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22892;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22889>:
        D.22801 = ip + 1;
        D.22802 = *D.22801;
        D.22885 = (signed char) D.22802;
        D.22886 = (int) D.22885;
        D.22887 = D.22886 + 2;
        do_branch_op (&ctx, D.22887, &cmp_br_op);
        ip = ip + 2;
        need_merge = 1;
        goto <D.21677>;
        <D.21751>:
        <D.21752>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.22893>; else goto <D.22895>;
        <D.22895>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.22893>; else goto <D.22894>;
        <D.22893>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22896 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22896;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22897 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22897;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22894>:
        D.22801 = ip + 1;
        D.22898 = mono_read32 (D.22801);
        D.22899 = (int) D.22898;
        D.22900 = D.22899 + 5;
        do_branch_op (&ctx, D.22900, &cmp_br_eq_op);
        ip = ip + 5;
        need_merge = 1;
        goto <D.21677>;
        <D.21754>:
        <D.21755>:
        <D.21756>:
        <D.21757>:
        <D.21758>:
        <D.21759>:
        <D.21760>:
        <D.21761>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.22901>; else goto <D.22903>;
        <D.22903>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.22901>; else goto <D.22902>;
        <D.22901>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22904 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22904;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22905 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22905;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22902>:
        D.22801 = ip + 1;
        D.22906 = mono_read32 (D.22801);
        D.22907 = (int) D.22906;
        D.22908 = D.22907 + 5;
        do_branch_op (&ctx, D.22908, &cmp_br_op);
        ip = ip + 5;
        need_merge = 1;
        goto <D.21677>;
        <D.21763>:
        <D.21764>:
        D.22795 = ip + 2;
        if (D.22795 > end) goto <D.22909>; else goto <D.22911>;
        <D.22911>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967293) goto <D.22909>; else goto <D.22910>;
        <D.22909>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22912 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22912;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22913 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22913;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22910>:
        D.22801 = ip + 1;
        D.22802 = *D.22801;
        D.22818 = (unsigned int) D.22802;
        D.22690 = *ip;
        D.22914 = D.22690 == 18;
        D.22915 = (int) D.22914;
        push_local (&ctx, D.22818, D.22915);
        ip = ip + 2;
        goto <D.21677>;
        <D.21766>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22916 = monoeg_g_strdup_printf ("Use of the `unused\' opcode");
          vinfo->info.message = D.22916;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22917 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22917;
        }
        ctx.valid = 0;
        ip = ip + 1;
        goto <D.21677>;
        <D.21768>:
        {
          struct ILStackDesc * top;

          D.22918 = check_underflow (&ctx, 1);
          if (D.22918 == 0) goto <D.21677>; else goto <D.22919>;
          <D.22919>:
          D.22920 = check_overflow (&ctx);
          if (D.22920 == 0) goto <D.21677>; else goto <D.22921>;
          <D.22921>:
          top = stack_push (&ctx);
          D.22922 = stack_peek (&ctx, 1);
          copy_stack_value (top, D.22922);
          ip = ip + 1;
          goto <D.21677>;
        }
        <D.21770>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.22923>; else goto <D.22925>;
        <D.22925>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.22923>; else goto <D.22924>;
        <D.22923>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22926 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22926;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22927 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22927;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22924>:
        D.22767 = ctx.eval.size;
        if (D.22767 != 0) goto <D.22928>; else goto <D.22929>;
        <D.22928>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22930 = monoeg_g_strdup_printf ("Eval stack must be empty in jmp at 0x%04x", ip_offset);
          vinfo->info.message = D.22930;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22931 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22931;
        }
        ctx.valid = 0;
        <D.22929>:
        D.22801 = ip + 1;
        token = mono_read32 (D.22801);
        D.22449 = ctx.header;
        D.22932 = in_any_block (D.22449, ip_offset);
        if (D.22932 != 0) goto <D.22933>; else goto <D.22934>;
        <D.22933>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22935 = monoeg_g_strdup_printf ("jmp cannot escape exception blocks at 0x%04x", ip_offset);
          vinfo->info.message = D.22935;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22936 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22936;
        }
        ctx.valid = 0;
        <D.22934>:
        D.22482 = ctx.verifiable;
        if (D.22482 != 0) goto <D.22937>; else goto <D.22939>;
        <D.22939>:
        D.22484 = ctx.level;
        D.22485 = D.22484 & 128;
        if (D.22485 != 0) goto <D.22937>; else goto <D.22938>;
        <D.22937>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.22798 = ctx.ip_offset;
          D.22940 = monoeg_g_strdup_printf ("Intruction jmp is not verifiable at 0x%04x", D.22798);
          vinfo->info.message = D.22940;
          vinfo->exception_type = 4;
          D.22431 = ctx.list;
          D.22941 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22941;
        }
        ctx.verifiable = 0;
        D.22484 = ctx.level;
        D.22488 = D.22484 & 16;
        if (D.22488 != 0) goto <D.22942>; else goto <D.22943>;
        <D.22942>:
        ctx.valid = 0;
        <D.22943>:
        <D.22938>:
        ip = ip + 5;
        goto <D.21677>;
        <D.21775>:
        <D.21776>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.22944>; else goto <D.22946>;
        <D.22946>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.22944>; else goto <D.22945>;
        <D.22944>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22947 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22947;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22948 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22948;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22945>:
        D.22801 = ip + 1;
        D.22949 = mono_read32 (D.22801);
        D.22950 = (int) D.22949;
        D.22690 = *ip;
        D.22951 = D.22690 == 111;
        D.22952 = (int) D.22951;
        do_invoke_method (&ctx, D.22950, D.22952);
        ip = ip + 5;
        goto <D.21677>;
        <D.21778>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.22953>; else goto <D.22955>;
        <D.22955>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.22953>; else goto <D.22954>;
        <D.22953>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22956 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22956;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22957 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22957;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22954>:
        D.22801 = ip + 1;
        token = mono_read32 (D.22801);
        D.22482 = ctx.verifiable;
        if (D.22482 != 0) goto <D.22958>; else goto <D.22960>;
        <D.22960>:
        D.22484 = ctx.level;
        D.22485 = D.22484 & 128;
        if (D.22485 != 0) goto <D.22958>; else goto <D.22959>;
        <D.22958>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.22798 = ctx.ip_offset;
          D.22961 = monoeg_g_strdup_printf ("Intruction calli is not verifiable at 0x%04x", D.22798);
          vinfo->info.message = D.22961;
          vinfo->exception_type = 4;
          D.22431 = ctx.list;
          D.22962 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22962;
        }
        ctx.verifiable = 0;
        D.22484 = ctx.level;
        D.22488 = D.22484 & 16;
        if (D.22488 != 0) goto <D.22963>; else goto <D.22964>;
        <D.22963>:
        ctx.valid = 0;
        <D.22964>:
        <D.22959>:
        ip = ip + 5;
        goto <D.21677>;
        <D.21781>:
        D.22795 = ip + 2;
        if (D.22795 > end) goto <D.22965>; else goto <D.22967>;
        <D.22967>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967293) goto <D.22965>; else goto <D.22966>;
        <D.22965>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22968 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22968;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22969 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22969;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22966>:
        D.22801 = ip + 1;
        D.22802 = *D.22801;
        D.22885 = (signed char) D.22802;
        D.22886 = (int) D.22885;
        D.22887 = D.22886 + 2;
        do_static_branch (&ctx, D.22887);
        need_merge = 1;
        ip = ip + 2;
        start = 1;
        goto <D.21677>;
        <D.21783>:
        <D.21784>:
        D.22795 = ip + 2;
        if (D.22795 > end) goto <D.22970>; else goto <D.22972>;
        <D.22972>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967293) goto <D.22970>; else goto <D.22971>;
        <D.22970>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22973 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22973;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22974 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22974;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22971>:
        D.22801 = ip + 1;
        D.22802 = *D.22801;
        D.22885 = (signed char) D.22802;
        D.22886 = (int) D.22885;
        D.22887 = D.22886 + 2;
        do_boolean_branch_op (&ctx, D.22887);
        ip = ip + 2;
        need_merge = 1;
        goto <D.21677>;
        <D.21786>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.22975>; else goto <D.22977>;
        <D.22977>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.22975>; else goto <D.22976>;
        <D.22975>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22978 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22978;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22979 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22979;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22976>:
        D.22801 = ip + 1;
        D.22980 = mono_read32 (D.22801);
        D.22981 = (int) D.22980;
        D.22982 = D.22981 + 5;
        do_static_branch (&ctx, D.22982);
        need_merge = 1;
        ip = ip + 5;
        start = 1;
        goto <D.21677>;
        <D.21788>:
        <D.21789>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.22983>; else goto <D.22985>;
        <D.22985>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.22983>; else goto <D.22984>;
        <D.22983>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.22986 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.22986;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.22987 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.22987;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.22984>:
        D.22801 = ip + 1;
        D.22988 = mono_read32 (D.22801);
        D.22989 = (int) D.22988;
        D.22990 = D.22989 + 5;
        do_boolean_branch_op (&ctx, D.22990);
        ip = ip + 5;
        need_merge = 1;
        goto <D.21677>;
        <D.21791>:
        {
          guint32 entries;

          D.22839 = ip + 5;
          if (D.22839 > end) goto <D.22991>; else goto <D.22993>;
          <D.22993>:
          ip.23 = (unsigned int) ip;
          if (ip.23 > 4294967290) goto <D.22991>; else goto <D.22992>;
          <D.22991>:
          {
            struct MonoVerifyInfoExtended * vinfo;

            vinfo = monoeg_malloc (12);
            vinfo->info.status = 1;
            D.22690 = *ip;
            D.22691 = (int) D.22690;
            D.22798 = ctx.ip_offset;
            D.22994 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
            vinfo->info.message = D.22994;
            vinfo->exception_type = 3;
            D.22431 = ctx.list;
            D.22995 = monoeg_g_slist_prepend (D.22431, vinfo);
            ctx.list = D.22995;
          }
          ctx.valid = 0;
          goto <D.21677>;
          <D.22992>:
          D.22801 = ip + 1;
          entries = mono_read32 (D.22801);
          if (entries > 1073741823) goto <D.22996>; else goto <D.22997>;
          <D.22996>:
          {
            struct MonoVerifyInfoExtended * vinfo;

            vinfo = monoeg_malloc (12);
            vinfo->info.status = 1;
            D.22798 = ctx.ip_offset;
            D.22998 = monoeg_g_strdup_printf ("Too many switch entries %x at 0x%04x", entries, D.22798);
            vinfo->info.message = D.22998;
            vinfo->exception_type = 3;
            D.22431 = ctx.list;
            D.22999 = monoeg_g_slist_prepend (D.22431, vinfo);
            ctx.list = D.22999;
          }
          ctx.valid = 0;
          <D.22997>:
          ip = ip + 5;
          D.23002 = entries * 4;
          D.23003 = ip + D.23002;
          if (D.23003 > end) goto <D.23000>; else goto <D.23004>;
          <D.23004>:
          D.23002 = entries * 4;
          D.23005 = ~D.23002;
          ip.23 = (unsigned int) ip;
          if (D.23005 < ip.23) goto <D.23000>; else goto <D.23001>;
          <D.23000>:
          {
            struct MonoVerifyInfoExtended * vinfo;

            vinfo = monoeg_malloc (12);
            vinfo->info.status = 1;
            D.22690 = *ip;
            D.22691 = (int) D.22690;
            D.22798 = ctx.ip_offset;
            D.23006 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
            vinfo->info.message = D.23006;
            vinfo->exception_type = 3;
            D.22431 = ctx.list;
            D.23007 = monoeg_g_slist_prepend (D.22431, vinfo);
            ctx.list = D.23007;
          }
          ctx.valid = 0;
          goto <D.21677>;
          <D.23001>:
          entries.24 = (int) entries;
          do_switch (&ctx, entries.24, ip);
          D.23002 = entries * 4;
          ip = ip + D.23002;
          goto <D.21677>;
        }
        <D.21796>:
        <D.21797>:
        <D.21798>:
        <D.21799>:
        <D.21800>:
        <D.21801>:
        <D.21802>:
        <D.21803>:
        <D.21804>:
        <D.21805>:
        <D.21806>:
        D.22690 = *ip;
        D.22691 = (int) D.22690;
        do_load_indirect (&ctx, D.22691);
        ip = ip + 1;
        goto <D.21677>;
        <D.21807>:
        <D.21808>:
        <D.21809>:
        <D.21810>:
        <D.21811>:
        <D.21812>:
        <D.21813>:
        <D.21814>:
        D.22690 = *ip;
        D.22691 = (int) D.22690;
        do_store_indirect (&ctx, D.22691);
        ip = ip + 1;
        goto <D.21677>;
        <D.21815>:
        <D.21816>:
        D.22690 = *ip;
        D.22691 = (int) D.22690;
        do_unary_math_op (&ctx, D.22691);
        ip = ip + 1;
        goto <D.21677>;
        <D.21817>:
        <D.21818>:
        <D.21819>:
        <D.21820>:
        <D.21821>:
        <D.21822>:
        do_conversion (&ctx, 1);
        ip = ip + 1;
        goto <D.21677>;
        <D.21823>:
        <D.21824>:
        do_conversion (&ctx, 2);
        ip = ip + 1;
        goto <D.21677>;
        <D.21825>:
        <D.21826>:
        <D.21827>:
        do_conversion (&ctx, 4);
        ip = ip + 1;
        goto <D.21677>;
        <D.21828>:
        <D.21829>:
        do_conversion (&ctx, 3);
        ip = ip + 1;
        goto <D.21677>;
        <D.21830>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23009>; else goto <D.23011>;
        <D.23011>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23009>; else goto <D.23010>;
        <D.23009>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23012 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23012;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23013 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23013;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23010>:
        D.22801 = ip + 1;
        D.23014 = mono_read32 (D.22801);
        D.23015 = (int) D.23014;
        do_cpobj (&ctx, D.23015);
        ip = ip + 5;
        goto <D.21677>;
        <D.21832>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23016>; else goto <D.23018>;
        <D.23018>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23016>; else goto <D.23017>;
        <D.23016>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23019 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23019;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23020 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23020;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23017>:
        D.22801 = ip + 1;
        D.23021 = mono_read32 (D.22801);
        D.23022 = (int) D.23021;
        do_ldobj_value (&ctx, D.23022);
        ip = ip + 5;
        goto <D.21677>;
        <D.21834>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23023>; else goto <D.23025>;
        <D.23025>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23023>; else goto <D.23024>;
        <D.23023>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23026 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23026;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23027 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23027;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23024>:
        D.22801 = ip + 1;
        D.23028 = mono_read32 (D.22801);
        do_ldstr (&ctx, D.23028);
        ip = ip + 5;
        goto <D.21677>;
        <D.21836>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23029>; else goto <D.23031>;
        <D.23031>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23029>; else goto <D.23030>;
        <D.23029>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23032 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23032;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23033 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23033;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23030>:
        D.22801 = ip + 1;
        D.23034 = mono_read32 (D.22801);
        D.23035 = (int) D.23034;
        do_newobj (&ctx, D.23035);
        ip = ip + 5;
        goto <D.21677>;
        <D.21838>:
        <D.21839>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23036>; else goto <D.23038>;
        <D.23038>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23036>; else goto <D.23037>;
        <D.23036>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23039 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23039;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23040 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23040;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23037>:
        D.22801 = ip + 1;
        D.23041 = mono_read32 (D.22801);
        D.23042 = (int) D.23041;
        D.22690 = *ip;
        if (D.22690 == 116) goto <D.23044>; else goto <D.23045>;
        <D.23044>:
        iftmp.25 = "castclass";
        goto <D.23046>;
        <D.23045>:
        iftmp.25 = "isinst";
        <D.23046>:
        do_cast (&ctx, D.23042, iftmp.25);
        ip = ip + 5;
        goto <D.21677>;
        <D.21841>:
        <D.21842>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.23047 = monoeg_g_strdup_printf ("Use of the `unused\' opcode");
          vinfo->info.message = D.23047;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23048 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23048;
        }
        ctx.valid = 0;
        ip = ip + 1;
        goto <D.21677>;
        <D.21844>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23049>; else goto <D.23051>;
        <D.23051>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23049>; else goto <D.23050>;
        <D.23049>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23052 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23052;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23053 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23053;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23050>:
        D.22801 = ip + 1;
        D.23054 = mono_read32 (D.22801);
        D.23055 = (int) D.23054;
        do_unbox_value (&ctx, D.23055);
        ip = ip + 5;
        goto <D.21677>;
        <D.21846>:
        do_throw (&ctx);
        start = 1;
        ip = ip + 1;
        goto <D.21677>;
        <D.21847>:
        <D.21848>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23056>; else goto <D.23058>;
        <D.23058>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23056>; else goto <D.23057>;
        <D.23056>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23059 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23059;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23060 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23060;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23057>:
        D.22801 = ip + 1;
        D.23061 = mono_read32 (D.22801);
        D.23062 = (int) D.23061;
        D.22690 = *ip;
        D.23063 = D.22690 == 124;
        D.23064 = (int) D.23063;
        do_push_field (&ctx, D.23062, D.23064);
        ip = ip + 5;
        goto <D.21677>;
        <D.21850>:
        <D.21851>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23065>; else goto <D.23067>;
        <D.23067>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23065>; else goto <D.23066>;
        <D.23065>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23068 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23068;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23069 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23069;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23066>:
        D.22801 = ip + 1;
        D.23070 = mono_read32 (D.22801);
        D.23071 = (int) D.23070;
        D.22690 = *ip;
        D.23072 = D.22690 == 127;
        D.23073 = (int) D.23072;
        do_push_static_field (&ctx, D.23071, D.23073);
        ip = ip + 5;
        goto <D.21677>;
        <D.21853>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23074>; else goto <D.23076>;
        <D.23076>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23074>; else goto <D.23075>;
        <D.23074>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23077 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23077;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23078 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23078;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23075>:
        D.22801 = ip + 1;
        D.23079 = mono_read32 (D.22801);
        D.23080 = (int) D.23079;
        do_store_field (&ctx, D.23080);
        ip = ip + 5;
        goto <D.21677>;
        <D.21855>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23081>; else goto <D.23083>;
        <D.23083>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23081>; else goto <D.23082>;
        <D.23081>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23084 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23084;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23085 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23085;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23082>:
        D.22801 = ip + 1;
        D.23086 = mono_read32 (D.22801);
        D.23087 = (int) D.23086;
        do_store_static_field (&ctx, D.23087);
        ip = ip + 5;
        goto <D.21677>;
        <D.21857>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23088>; else goto <D.23090>;
        <D.23090>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23088>; else goto <D.23089>;
        <D.23088>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23091 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23091;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23092 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23092;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23089>:
        D.22801 = ip + 1;
        D.23093 = mono_read32 (D.22801);
        D.23094 = (int) D.23093;
        do_stobj (&ctx, D.23094);
        ip = ip + 5;
        goto <D.21677>;
        <D.21859>:
        <D.21860>:
        <D.21861>:
        <D.21862>:
        <D.21863>:
        <D.21864>:
        do_conversion (&ctx, 1);
        ip = ip + 1;
        goto <D.21677>;
        <D.21865>:
        <D.21866>:
        do_conversion (&ctx, 2);
        ip = ip + 1;
        goto <D.21677>;
        <D.21867>:
        <D.21868>:
        do_conversion (&ctx, 3);
        ip = ip + 1;
        goto <D.21677>;
        <D.21869>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23095>; else goto <D.23097>;
        <D.23097>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23095>; else goto <D.23096>;
        <D.23095>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23098 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23098;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23099 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23099;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23096>:
        D.22801 = ip + 1;
        D.23100 = mono_read32 (D.22801);
        D.23101 = (int) D.23100;
        do_box_value (&ctx, D.23101);
        ip = ip + 5;
        goto <D.21677>;
        <D.21871>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23102>; else goto <D.23104>;
        <D.23104>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23102>; else goto <D.23103>;
        <D.23102>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23105 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23105;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23106 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23106;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23103>:
        D.22801 = ip + 1;
        D.23107 = mono_read32 (D.22801);
        D.23108 = (int) D.23107;
        do_newarr (&ctx, D.23108);
        ip = ip + 5;
        goto <D.21677>;
        <D.21873>:
        do_ldlen (&ctx);
        ip = ip + 1;
        goto <D.21677>;
        <D.21874>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23109>; else goto <D.23111>;
        <D.23111>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23109>; else goto <D.23110>;
        <D.23109>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23112 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23112;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23113 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23113;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23110>:
        D.22801 = ip + 1;
        D.23114 = mono_read32 (D.22801);
        D.23115 = (int) D.23114;
        do_ldelema (&ctx, D.23115);
        ip = ip + 5;
        goto <D.21677>;
        <D.21876>:
        <D.21877>:
        <D.21878>:
        <D.21879>:
        <D.21880>:
        <D.21881>:
        <D.21882>:
        <D.21883>:
        <D.21884>:
        <D.21885>:
        <D.21886>:
        D.22690 = *ip;
        D.22691 = (int) D.22690;
        do_ldelem (&ctx, D.22691, 0);
        ip = ip + 1;
        goto <D.21677>;
        <D.21887>:
        <D.21888>:
        <D.21889>:
        <D.21890>:
        <D.21891>:
        <D.21892>:
        <D.21893>:
        <D.21894>:
        D.22690 = *ip;
        D.22691 = (int) D.22690;
        do_stelem (&ctx, D.22691, 0);
        ip = ip + 1;
        goto <D.21677>;
        <D.21895>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23116>; else goto <D.23118>;
        <D.23118>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23116>; else goto <D.23117>;
        <D.23116>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23119 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23119;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23120 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23120;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23117>:
        D.22690 = *ip;
        D.22691 = (int) D.22690;
        D.22801 = ip + 1;
        D.23121 = mono_read32 (D.22801);
        D.23122 = (int) D.23121;
        do_ldelem (&ctx, D.22691, D.23122);
        ip = ip + 5;
        goto <D.21677>;
        <D.21897>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23123>; else goto <D.23125>;
        <D.23125>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23123>; else goto <D.23124>;
        <D.23123>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23126 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23126;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23127 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23127;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23124>:
        D.22690 = *ip;
        D.22691 = (int) D.22690;
        D.22801 = ip + 1;
        D.23128 = mono_read32 (D.22801);
        D.23129 = (int) D.23128;
        do_stelem (&ctx, D.22691, D.23129);
        ip = ip + 5;
        goto <D.21677>;
        <D.21899>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23130>; else goto <D.23132>;
        <D.23132>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23130>; else goto <D.23131>;
        <D.23130>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23133 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23133;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23134 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23134;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23131>:
        D.22801 = ip + 1;
        D.23135 = mono_read32 (D.22801);
        D.23136 = (int) D.23135;
        do_unbox_any (&ctx, D.23136);
        ip = ip + 5;
        goto <D.21677>;
        <D.21901>:
        <D.21902>:
        <D.21903>:
        <D.21904>:
        <D.21905>:
        <D.21906>:
        do_conversion (&ctx, 1);
        ip = ip + 1;
        goto <D.21677>;
        <D.21907>:
        <D.21908>:
        do_conversion (&ctx, 2);
        ip = ip + 1;
        goto <D.21677>;
        <D.21909>:
        <D.21910>:
        do_conversion (&ctx, 3);
        ip = ip + 1;
        goto <D.21677>;
        <D.21911>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23137>; else goto <D.23139>;
        <D.23139>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23137>; else goto <D.23138>;
        <D.23137>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23140 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23140;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23141 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23141;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23138>:
        D.22801 = ip + 1;
        D.23142 = mono_read32 (D.22801);
        D.23143 = (int) D.23142;
        do_refanyval (&ctx, D.23143);
        ip = ip + 5;
        goto <D.21677>;
        <D.21913>:
        do_ckfinite (&ctx);
        ip = ip + 1;
        goto <D.21677>;
        <D.21914>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23144>; else goto <D.23146>;
        <D.23146>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23144>; else goto <D.23145>;
        <D.23144>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23147 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23147;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23148 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23148;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23145>:
        D.22801 = ip + 1;
        D.23149 = mono_read32 (D.22801);
        D.23150 = (int) D.23149;
        do_mkrefany (&ctx, D.23150);
        ip = ip + 5;
        goto <D.21677>;
        <D.21916>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23151>; else goto <D.23153>;
        <D.23153>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23151>; else goto <D.23152>;
        <D.23151>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23154 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23154;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23155 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23155;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23152>:
        D.22801 = ip + 1;
        D.23156 = mono_read32 (D.22801);
        D.23157 = (int) D.23156;
        do_load_token (&ctx, D.23157);
        ip = ip + 5;
        goto <D.21677>;
        <D.21918>:
        D.22449 = ctx.header;
        D.23158 = is_correct_endfinally (D.22449, ip_offset);
        if (D.23158 == 0) goto <D.23159>; else goto <D.23160>;
        <D.23159>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22798 = ctx.ip_offset;
          D.23161 = monoeg_g_strdup_printf ("endfinally must be used inside a finally/fault handler at 0x%04x", D.22798);
          vinfo->info.message = D.23161;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23162 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23162;
        }
        ctx.valid = 0;
        <D.23160>:
        ctx.eval.size = 0;
        start = 1;
        ip = ip + 1;
        goto <D.21677>;
        <D.21920>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23163>; else goto <D.23165>;
        <D.23165>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23163>; else goto <D.23164>;
        <D.23163>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23166 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23166;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23167 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23167;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23164>:
        D.22801 = ip + 1;
        D.23168 = mono_read32 (D.22801);
        D.23169 = D.23168 + 5;
        D.23170 = (int) D.23169;
        do_leave (&ctx, D.23170);
        ip = ip + 5;
        start = 1;
        need_merge = 1;
        goto <D.21677>;
        <D.21922>:
        D.22795 = ip + 2;
        if (D.22795 > end) goto <D.23171>; else goto <D.23173>;
        <D.23173>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967293) goto <D.23171>; else goto <D.23172>;
        <D.23171>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23174 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23174;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23175 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23175;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23172>:
        D.22801 = ip + 1;
        D.22802 = *D.22801;
        D.22885 = (signed char) D.22802;
        D.22886 = (int) D.22885;
        D.22887 = D.22886 + 2;
        do_leave (&ctx, D.22887);
        ip = ip + 2;
        start = 1;
        need_merge = 1;
        goto <D.21677>;
        <D.21924>:
        D.22795 = ip + 2;
        if (D.22795 > end) goto <D.23176>; else goto <D.23178>;
        <D.23178>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967293) goto <D.23176>; else goto <D.23177>;
        <D.23176>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23179 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23179;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23180 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23180;
        }
        ctx.valid = 0;
        goto <D.21677>;
        <D.23177>:
        ip = ip + 1;
        D.22690 = *ip;
        D.22691 = (int) D.22690;
        switch (D.22691) <default: <D.21975>, case 0: <D.21936>, case 1: <D.21929>, case 2: <D.21930>, case 3: <D.21931>, case 4: <D.21932>, case 5: <D.21933>, case 6: <D.21938>, case 7: <D.21940>, case 8: <D.21949>, case 9: <D.21942>, case 10: <D.21943>, case 11: <D.21934>, case 12: <D.21945>, case 13: <D.21946>, case 14: <D.21926>, case 15: <D.21948>, case 16: <D.21950>, case 17: <D.21954>, case 18: <D.21955>, case 19: <D.21957>, case 20: <D.21958>, case 21: <D.21960>, case 22: <D.21962>, case 23: <D.21965>, case 24: <D.21967>, case 25: <D.21969>, case 26: <D.21970>, case 27: <D.21952>, case 28: <D.21972>, case 29: <D.21974>, case 30: <D.21964>, case 34: <D.21951>>
        <D.21926>:
        D.23183 = ip + 3;
        if (D.23183 > end) goto <D.23181>; else goto <D.23184>;
        <D.23184>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967292) goto <D.23181>; else goto <D.23182>;
        <D.23181>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23185 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23185;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23186 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23186;
        }
        ctx.valid = 0;
        goto <D.21928>;
        <D.23182>:
        D.22801 = ip + 1;
        D.23187 = mono_read16 (D.22801);
        D.23188 = (unsigned int) D.23187;
        store_local (&ctx, D.23188);
        ip = ip + 3;
        goto <D.21928>;
        <D.21929>:
        D.22690 = *ip;
        D.23189 = (unsigned int) D.22690;
        do_cmp_op (&ctx, &cmp_br_eq_op, D.23189);
        ip = ip + 1;
        goto <D.21928>;
        <D.21930>:
        <D.21931>:
        <D.21932>:
        <D.21933>:
        D.22690 = *ip;
        D.23189 = (unsigned int) D.22690;
        do_cmp_op (&ctx, &cmp_br_op, D.23189);
        ip = ip + 1;
        goto <D.21928>;
        <D.21934>:
        D.23183 = ip + 3;
        if (D.23183 > end) goto <D.23190>; else goto <D.23192>;
        <D.23192>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967292) goto <D.23190>; else goto <D.23191>;
        <D.23190>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23193 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23193;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23194 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23194;
        }
        ctx.valid = 0;
        goto <D.21928>;
        <D.23191>:
        D.22801 = ip + 1;
        D.23195 = mono_read16 (D.22801);
        D.23196 = (unsigned int) D.23195;
        store_arg (&ctx, D.23196);
        ip = ip + 3;
        goto <D.21928>;
        <D.21936>:
        D.23197 = check_overflow (&ctx);
        if (D.23197 == 0) goto <D.21928>; else goto <D.23198>;
        <D.23198>:
        D.22427 = ctx.signature;
        D.22495 = BIT_FIELD_REF <*D.22427, 8, 80>;
        D.23199 = D.22495 & 63;
        if (D.23199 != 5) goto <D.23200>; else goto <D.23201>;
        <D.23200>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22798 = ctx.ip_offset;
          D.23202 = monoeg_g_strdup_printf ("Cannot use arglist on method without VARGARG calling convention at 0x%04x", D.22798);
          vinfo->info.message = D.23202;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23203 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23203;
        }
        ctx.valid = 0;
        <D.23201>:
        D.23204 = stack_push (&ctx);
        D.23205 = mono_defaults.argumenthandle_class;
        D.23206 = &D.23205->byval_arg;
        set_stack_value (&ctx, D.23204, D.23206, 0);
        ip = ip + 1;
        goto <D.21928>;
        <D.21938>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23207>; else goto <D.23209>;
        <D.23209>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23207>; else goto <D.23208>;
        <D.23207>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23210 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23210;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23211 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23211;
        }
        ctx.valid = 0;
        goto <D.21928>;
        <D.23208>:
        D.22801 = ip + 1;
        D.23212 = mono_read32 (D.22801);
        do_load_function_ptr (&ctx, D.23212, 0);
        ip = ip + 5;
        goto <D.21928>;
        <D.21940>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23213>; else goto <D.23215>;
        <D.23215>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23213>; else goto <D.23214>;
        <D.23213>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23216 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23216;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23217 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23217;
        }
        ctx.valid = 0;
        goto <D.21928>;
        <D.23214>:
        D.22801 = ip + 1;
        D.23218 = mono_read32 (D.22801);
        do_load_function_ptr (&ctx, D.23218, 1);
        ip = ip + 5;
        goto <D.21928>;
        <D.21942>:
        <D.21943>:
        D.23183 = ip + 3;
        if (D.23183 > end) goto <D.23219>; else goto <D.23221>;
        <D.23221>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967292) goto <D.23219>; else goto <D.23220>;
        <D.23219>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23222 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23222;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23223 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23223;
        }
        ctx.valid = 0;
        goto <D.21928>;
        <D.23220>:
        D.22801 = ip + 1;
        D.23224 = mono_read16 (D.22801);
        D.23225 = (unsigned int) D.23224;
        D.22690 = *ip;
        D.23226 = D.22690 == 10;
        D.23227 = (int) D.23226;
        push_arg (&ctx, D.23225, D.23227);
        ip = ip + 3;
        goto <D.21928>;
        <D.21945>:
        <D.21946>:
        D.23183 = ip + 3;
        if (D.23183 > end) goto <D.23228>; else goto <D.23230>;
        <D.23230>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967292) goto <D.23228>; else goto <D.23229>;
        <D.23228>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23231 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23231;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23232 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23232;
        }
        ctx.valid = 0;
        goto <D.21928>;
        <D.23229>:
        D.22801 = ip + 1;
        D.23233 = mono_read16 (D.22801);
        D.23234 = (unsigned int) D.23233;
        D.22690 = *ip;
        D.23235 = D.22690 == 13;
        D.23236 = (int) D.23235;
        push_local (&ctx, D.23234, D.23236);
        ip = ip + 3;
        goto <D.21928>;
        <D.21948>:
        do_localloc (&ctx);
        ip = ip + 1;
        goto <D.21928>;
        <D.21949>:
        <D.21950>:
        <D.21951>:
        <D.21952>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.23237 = monoeg_g_strdup_printf ("Use of the `unused\' opcode");
          vinfo->info.message = D.23237;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23238 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23238;
        }
        ctx.valid = 0;
        ip = ip + 1;
        goto <D.21928>;
        <D.21954>:
        do_endfilter (&ctx);
        start = 1;
        ip = ip + 1;
        goto <D.21928>;
        <D.21955>:
        D.22795 = ip + 2;
        if (D.22795 > end) goto <D.23239>; else goto <D.23241>;
        <D.23241>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967293) goto <D.23239>; else goto <D.23240>;
        <D.23239>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23242 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23242;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23243 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23243;
        }
        ctx.valid = 0;
        goto <D.21928>;
        <D.23240>:
        prefix = prefix | 1;
        ip = ip + 2;
        goto <D.21928>;
        <D.21957>:
        prefix = prefix | 2;
        ip = ip + 1;
        goto <D.21928>;
        <D.21958>:
        prefix = prefix | 4;
        ip = ip + 1;
        if (ip < end) goto <D.23244>; else goto <D.23245>;
        <D.23244>:
        D.22690 = *ip;
        D.23246 = D.22690 + 216;
        D.23247 = D.23246 > 1;
        D.22690 = *ip;
        D.23248 = D.22690 != 111;
        D.23249 = D.23247 & D.23248;
        if (D.23249 != 0) goto <D.23250>; else goto <D.23251>;
        <D.23250>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.23252 = monoeg_g_strdup_printf ("tail prefix must be used only with call opcodes at 0x%04x", ip_offset);
          vinfo->info.message = D.23252;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23253 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23253;
        }
        ctx.valid = 0;
        <D.23251>:
        <D.23245>:
        goto <D.21928>;
        <D.21960>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23254>; else goto <D.23256>;
        <D.23256>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23254>; else goto <D.23255>;
        <D.23254>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23257 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23257;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23258 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23258;
        }
        ctx.valid = 0;
        goto <D.21928>;
        <D.23255>:
        D.22801 = ip + 1;
        D.23259 = mono_read32 (D.22801);
        D.23260 = (int) D.23259;
        do_initobj (&ctx, D.23260);
        ip = ip + 5;
        goto <D.21928>;
        <D.21962>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23261>; else goto <D.23263>;
        <D.23263>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23261>; else goto <D.23262>;
        <D.23261>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23264 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23264;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23265 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23265;
        }
        ctx.valid = 0;
        goto <D.21928>;
        <D.23262>:
        D.22801 = ip + 1;
        D.23266 = mono_read32 (D.22801);
        D.23267 = (int) D.23266;
        D.23268 = get_boxable_mono_type (&ctx, D.23267, "constrained.");
        ctx.constrained_type = D.23268;
        prefix = prefix | 8;
        ip = ip + 5;
        goto <D.21928>;
        <D.21964>:
        prefix = prefix | 16;
        ip = ip + 1;
        goto <D.21928>;
        <D.21965>:
        D.23269 = ctx.prefix_set;
        D.23270 = D.23269 & 4294967292;
        ctx.prefix_set = D.23270;
        D.23271 = check_underflow (&ctx, 3);
        if (D.23271 == 0) goto <D.21928>; else goto <D.23272>;
        <D.23272>:
        D.22482 = ctx.verifiable;
        if (D.22482 != 0) goto <D.23273>; else goto <D.23275>;
        <D.23275>:
        D.22484 = ctx.level;
        D.22485 = D.22484 & 128;
        if (D.22485 != 0) goto <D.23273>; else goto <D.23274>;
        <D.23273>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.22798 = ctx.ip_offset;
          D.23276 = monoeg_g_strdup_printf ("Instruction cpblk is not verifiable at 0x%04x", D.22798);
          vinfo->info.message = D.23276;
          vinfo->exception_type = 4;
          D.22431 = ctx.list;
          D.23277 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23277;
        }
        ctx.verifiable = 0;
        D.22484 = ctx.level;
        D.22488 = D.22484 & 16;
        if (D.22488 != 0) goto <D.23278>; else goto <D.23279>;
        <D.23278>:
        ctx.valid = 0;
        <D.23279>:
        <D.23274>:
        ip = ip + 1;
        goto <D.21928>;
        <D.21967>:
        D.23269 = ctx.prefix_set;
        D.23270 = D.23269 & 4294967292;
        ctx.prefix_set = D.23270;
        D.23280 = check_underflow (&ctx, 3);
        if (D.23280 == 0) goto <D.21928>; else goto <D.23281>;
        <D.23281>:
        D.22482 = ctx.verifiable;
        if (D.22482 != 0) goto <D.23282>; else goto <D.23284>;
        <D.23284>:
        D.22484 = ctx.level;
        D.22485 = D.22484 & 128;
        if (D.22485 != 0) goto <D.23282>; else goto <D.23283>;
        <D.23282>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.22798 = ctx.ip_offset;
          D.23285 = monoeg_g_strdup_printf ("Instruction initblk is not verifiable at 0x%04x", D.22798);
          vinfo->info.message = D.23285;
          vinfo->exception_type = 4;
          D.22431 = ctx.list;
          D.23286 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23286;
        }
        ctx.verifiable = 0;
        D.22484 = ctx.level;
        D.22488 = D.22484 & 16;
        if (D.22488 != 0) goto <D.23287>; else goto <D.23288>;
        <D.23287>:
        ctx.valid = 0;
        <D.23288>:
        <D.23283>:
        ip = ip + 1;
        goto <D.21928>;
        <D.21969>:
        ip = ip + 2;
        goto <D.21928>;
        <D.21970>:
        D.22449 = ctx.header;
        D.23289 = is_correct_rethrow (D.22449, ip_offset);
        if (D.23289 == 0) goto <D.23290>; else goto <D.23291>;
        <D.23290>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22798 = ctx.ip_offset;
          D.23292 = monoeg_g_strdup_printf ("rethrow must be used inside a catch handler at 0x%04x", D.22798);
          vinfo->info.message = D.23292;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23293 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23293;
        }
        ctx.valid = 0;
        <D.23291>:
        ctx.eval.size = 0;
        start = 1;
        ip = ip + 1;
        goto <D.21928>;
        <D.21972>:
        D.22839 = ip + 5;
        if (D.22839 > end) goto <D.23294>; else goto <D.23296>;
        <D.23296>:
        ip.23 = (unsigned int) ip;
        if (ip.23 > 4294967290) goto <D.23294>; else goto <D.23295>;
        <D.23294>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23297 = monoeg_g_strdup_printf ("Code overrun starting with 0x%x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23297;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23298 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23298;
        }
        ctx.valid = 0;
        goto <D.21928>;
        <D.23295>:
        D.22801 = ip + 1;
        D.23299 = mono_read32 (D.22801);
        D.23300 = (int) D.23299;
        do_sizeof (&ctx, D.23300);
        ip = ip + 5;
        goto <D.21928>;
        <D.21974>:
        do_refanytype (&ctx);
        ip = ip + 1;
        goto <D.21928>;
        <D.21975>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23301 = monoeg_g_strdup_printf ("Invalid instruction FE %x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23301;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23302 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23302;
        }
        ctx.valid = 0;
        ip = ip + 1;
        <D.21928>:
        goto <D.21677>;
        <D.21977>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22690 = *ip;
          D.22691 = (int) D.22690;
          D.22798 = ctx.ip_offset;
          D.23303 = monoeg_g_strdup_printf ("Invalid instruction %x at 0x%04x", D.22691, D.22798);
          vinfo->info.message = D.23303;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23304 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23304;
        }
        ctx.valid = 0;
        ip = ip + 1;
        <D.21677>:
        if (prefix != 0) goto <D.23305>; else goto <D.23306>;
        <D.23305>:
        D.23269 = ctx.prefix_set;
        if (D.23269 == 0) goto <D.23307>; else goto <D.23308>;
        <D.23307>:
        D.22466 = ctx.code;
        D.22798 = ctx.ip_offset;
        D.23309 = D.22798 * 12;
        D.23310 = D.22466 + D.23309;
        D.22466 = ctx.code;
        D.22798 = ctx.ip_offset;
        D.23309 = D.22798 * 12;
        D.23310 = D.22466 + D.23309;
        D.23311 = D.23310->flags;
        D.23312 = D.23311 | 1;
        D.23310->flags = D.23312;
        <D.23308>:
        D.23269 = ctx.prefix_set;
        D.23313 = D.23269 | prefix;
        ctx.prefix_set = D.23313;
        ctx.has_flags = 1;
        prefix = 0;
        goto <D.23314>;
        <D.23306>:
        D.23315 = ctx.has_flags;
        if (D.23315 == 0) goto <D.23316>; else goto <D.23317>;
        <D.23316>:
        D.22466 = ctx.code;
        D.22798 = ctx.ip_offset;
        D.23309 = D.22798 * 12;
        D.23310 = D.22466 + D.23309;
        D.22466 = ctx.code;
        D.22798 = ctx.ip_offset;
        D.23309 = D.22798 * 12;
        D.23310 = D.22466 + D.23309;
        D.23311 = D.23310->flags;
        D.23312 = D.23311 | 1;
        D.23310->flags = D.23312;
        <D.23317>:
        D.23269 = ctx.prefix_set;
        D.23318 = D.23269 & 8;
        if (D.23318 != 0) goto <D.23319>; else goto <D.23320>;
        <D.23319>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22798 = ctx.ip_offset;
          D.23321 = monoeg_g_strdup_printf ("Invalid instruction after constrained prefix at 0x%04x", D.22798);
          vinfo->info.message = D.23321;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23322 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23322;
        }
        ctx.valid = 0;
        <D.23320>:
        D.23269 = ctx.prefix_set;
        D.23323 = D.23269 & 16;
        if (D.23323 != 0) goto <D.23324>; else goto <D.23325>;
        <D.23324>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22798 = ctx.ip_offset;
          D.23326 = monoeg_g_strdup_printf ("Invalid instruction after readonly prefix at 0x%04x", D.22798);
          vinfo->info.message = D.23326;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23327 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23327;
        }
        ctx.valid = 0;
        <D.23325>:
        D.23269 = ctx.prefix_set;
        D.23328 = D.23269 & 2;
        if (D.23328 != 0) goto <D.23329>; else goto <D.23330>;
        <D.23329>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22798 = ctx.ip_offset;
          D.23331 = monoeg_g_strdup_printf ("Invalid instruction after volatile prefix at 0x%04x", D.22798);
          vinfo->info.message = D.23331;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23332 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23332;
        }
        ctx.valid = 0;
        <D.23330>:
        D.23269 = ctx.prefix_set;
        D.23333 = D.23269 & 1;
        if (D.23333 != 0) goto <D.23334>; else goto <D.23335>;
        <D.23334>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22798 = ctx.ip_offset;
          D.23336 = monoeg_g_strdup_printf ("Invalid instruction after unaligned prefix at 0x%04x", D.22798);
          vinfo->info.message = D.23336;
          vinfo->exception_type = 3;
          D.22431 = ctx.list;
          D.23337 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23337;
        }
        ctx.valid = 0;
        <D.23335>:
        prefix = 0;
        ctx.prefix_set = prefix;
        ctx.has_flags = 0;
        <D.23314>:
      }
      <D.21673>:
      if (ip < end) goto <D.23338>; else goto <D.21674>;
      <D.23338>:
      D.22462 = ctx.valid;
      if (D.22462 != 0) goto <D.21983>; else goto <D.21674>;
      <D.21674>:
      D.23339 = ip != end;
      D.23340 = start == 0;
      D.23341 = D.23339 | D.23340;
      if (D.23341 != 0) goto <D.23342>; else goto <D.23343>;
      <D.23342>:
      D.22482 = ctx.verifiable;
      if (D.22482 != 0) goto <D.23344>; else goto <D.23345>;
      <D.23344>:
      D.22431 = ctx.list;
      if (D.22431 == 0B) goto <D.23346>; else goto <D.23347>;
      <D.23346>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23348 = monoeg_g_strdup_printf ("Run ahead of method code at 0x%04x", ip_offset);
        vinfo->info.message = D.23348;
        vinfo->exception_type = 3;
        D.22431 = ctx.list;
        D.23349 = monoeg_g_slist_prepend (D.22431, vinfo);
        ctx.list = D.23349;
      }
      ctx.valid = 0;
      <D.23347>:
      <D.23345>:
      <D.23343>:
      i = 0;
      goto <D.21990>;
      <D.21989>:
      D.22466 = ctx.code;
      i.12 = (unsigned int) i;
      D.23350 = i.12 * 12;
      D.23351 = D.22466 + D.23350;
      D.23352 = D.23351->flags;
      D.23353 = (int) D.23352;
      D.23354 = D.23353 & 2;
      if (D.23354 != 0) goto <D.23355>; else goto <D.23356>;
      <D.23355>:
      D.22466 = ctx.code;
      i.12 = (unsigned int) i;
      D.23350 = i.12 * 12;
      D.23351 = D.22466 + D.23350;
      D.23352 = D.23351->flags;
      D.23353 = (int) D.23352;
      D.23357 = D.23353 & 1;
      if (D.23357 == 0) goto <D.23358>; else goto <D.23359>;
      <D.23358>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23360 = monoeg_g_strdup_printf ("Branch or exception block target middle of intruction at 0x%04x", i);
        vinfo->info.message = D.23360;
        vinfo->exception_type = 3;
        D.22431 = ctx.list;
        D.23361 = monoeg_g_slist_prepend (D.22431, vinfo);
        ctx.list = D.23361;
      }
      ctx.valid = 0;
      <D.23359>:
      D.22466 = ctx.code;
      i.12 = (unsigned int) i;
      D.23350 = i.12 * 12;
      D.23351 = D.22466 + D.23350;
      D.23352 = D.23351->flags;
      D.23353 = (int) D.23352;
      D.23362 = D.23353 & 16;
      if (D.23362 != 0) goto <D.23363>; else goto <D.23364>;
      <D.23363>:
      D.22482 = ctx.verifiable;
      if (D.22482 != 0) goto <D.23365>; else goto <D.23367>;
      <D.23367>:
      D.22484 = ctx.level;
      D.22485 = D.22484 & 128;
      if (D.22485 != 0) goto <D.23365>; else goto <D.23366>;
      <D.23365>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 8;
        D.23368 = monoeg_g_strdup_printf ("Branch to delegate code sequence at 0x%04x", i);
        vinfo->info.message = D.23368;
        vinfo->exception_type = 4;
        D.22431 = ctx.list;
        D.23369 = monoeg_g_slist_prepend (D.22431, vinfo);
        ctx.list = D.23369;
      }
      ctx.verifiable = 0;
      D.22484 = ctx.level;
      D.22488 = D.22484 & 16;
      if (D.22488 != 0) goto <D.23370>; else goto <D.23371>;
      <D.23370>:
      ctx.valid = 0;
      <D.23371>:
      <D.23366>:
      <D.23364>:
      <D.23356>:
      D.22466 = ctx.code;
      i.12 = (unsigned int) i;
      D.23350 = i.12 * 12;
      D.23351 = D.22466 + D.23350;
      D.23352 = D.23351->flags;
      D.23353 = (int) D.23352;
      D.23372 = D.23353 & 32;
      if (D.23372 != 0) goto <D.23373>; else goto <D.23374>;
      <D.23373>:
      D.23375 = ctx.has_this_store;
      if (D.23375 != 0) goto <D.23376>; else goto <D.23377>;
      <D.23376>:
      D.22482 = ctx.verifiable;
      if (D.22482 != 0) goto <D.23378>; else goto <D.23380>;
      <D.23380>:
      D.22484 = ctx.level;
      D.22485 = D.22484 & 128;
      if (D.22485 != 0) goto <D.23378>; else goto <D.23379>;
      <D.23378>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 8;
        D.23381 = monoeg_g_strdup_printf ("Invalid ldftn with virtual function in method with stdarg 0 at  0x%04x", i);
        vinfo->info.message = D.23381;
        vinfo->exception_type = 4;
        D.22431 = ctx.list;
        D.23382 = monoeg_g_slist_prepend (D.22431, vinfo);
        ctx.list = D.23382;
      }
      ctx.verifiable = 0;
      D.22484 = ctx.level;
      D.22488 = D.22484 & 16;
      if (D.22488 != 0) goto <D.23383>; else goto <D.23384>;
      <D.23383>:
      ctx.valid = 0;
      <D.23384>:
      <D.23379>:
      <D.23377>:
      <D.23374>:
      D.22466 = ctx.code;
      i.12 = (unsigned int) i;
      D.23350 = i.12 * 12;
      D.23351 = D.22466 + D.23350;
      D.23352 = D.23351->flags;
      D.23353 = (int) D.23352;
      D.23385 = D.23353 & 64;
      if (D.23385 != 0) goto <D.23386>; else goto <D.23387>;
      <D.23386>:
      D.23375 = ctx.has_this_store;
      if (D.23375 != 0) goto <D.23388>; else goto <D.23389>;
      <D.23388>:
      D.22482 = ctx.verifiable;
      if (D.22482 != 0) goto <D.23390>; else goto <D.23392>;
      <D.23392>:
      D.22484 = ctx.level;
      D.22485 = D.22484 & 128;
      if (D.22485 != 0) goto <D.23390>; else goto <D.23391>;
      <D.23390>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 8;
        D.23393 = monoeg_g_strdup_printf ("Invalid call to a non-final virtual function in method with stdarg.0 or ldarga.0 at  0x%04x", i);
        vinfo->info.message = D.23393;
        vinfo->exception_type = 4;
        D.22431 = ctx.list;
        D.23394 = monoeg_g_slist_prepend (D.22431, vinfo);
        ctx.list = D.23394;
      }
      ctx.verifiable = 0;
      D.22484 = ctx.level;
      D.22488 = D.22484 & 16;
      if (D.22488 != 0) goto <D.23395>; else goto <D.23396>;
      <D.23395>:
      ctx.valid = 0;
      <D.23396>:
      <D.23391>:
      <D.23389>:
      <D.23387>:
      i = i + 1;
      <D.21990>:
      D.22573 = ctx.code_size;
      if (D.22573 > i) goto <D.23397>; else goto <D.21991>;
      <D.23397>:
      i.26 = (unsigned int) i;
      if (i.26 < ip_offset) goto <D.21989>; else goto <D.21991>;
      <D.21991>:
      D.23399 = ctx.method;
      D.23400 = mono_method_is_constructor (D.23399);
      if (D.23400 != 0) goto <D.23401>; else goto <D.23402>;
      <D.23401>:
      D.23403 = ctx.super_ctor_called;
      if (D.23403 == 0) goto <D.23404>; else goto <D.23405>;
      <D.23404>:
      D.23399 = ctx.method;
      D.23406 = D.23399->klass;
      D.23407 = BIT_FIELD_REF <*D.23406, 8, 160>;
      D.23408 = D.23407 & 8;
      if (D.23408 == 0) goto <D.23409>; else goto <D.23410>;
      <D.23409>:
      D.23399 = ctx.method;
      D.23406 = D.23399->klass;
      D.22878 = mono_defaults.object_class;
      if (D.23406 != D.22878) goto <D.23411>; else goto <D.23412>;
      <D.23411>:
      {
        char * method_name;
        char * type;

        D.23399 = ctx.method;
        method_name = mono_method_full_name (D.23399, 1);
        D.23399 = ctx.method;
        D.23406 = D.23399->klass;
        type = mono_type_get_full_name (D.23406);
        D.23399 = ctx.method;
        D.23406 = D.23399->klass;
        D.23415 = D.23406->parent;
        if (D.23415 != 0B) goto <D.23416>; else goto <D.23413>;
        <D.23416>:
        D.23399 = ctx.method;
        D.23406 = D.23399->klass;
        D.23415 = D.23406->parent;
        D.23417 = D.23415->exception_type;
        if (D.23417 != 0) goto <D.23418>; else goto <D.23413>;
        <D.23418>:
        D.22482 = ctx.verifiable;
        if (D.22482 != 0) goto <D.23419>; else goto <D.23421>;
        <D.23421>:
        D.22484 = ctx.level;
        D.22485 = D.22484 & 128;
        if (D.22485 != 0) goto <D.23419>; else goto <D.23420>;
        <D.23419>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.23422 = monoeg_g_strdup_printf ("Constructor %s for type %s not calling base type ctor due to a TypeLoadException on base type.", method_name, type);
          vinfo->info.message = D.23422;
          vinfo->exception_type = 4;
          D.22431 = ctx.list;
          D.23423 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23423;
        }
        ctx.verifiable = 0;
        D.22484 = ctx.level;
        D.22488 = D.22484 & 16;
        if (D.22488 != 0) goto <D.23424>; else goto <D.23425>;
        <D.23424>:
        ctx.valid = 0;
        <D.23425>:
        <D.23420>:
        goto <D.23414>;
        <D.23413>:
        D.22482 = ctx.verifiable;
        if (D.22482 != 0) goto <D.23426>; else goto <D.23428>;
        <D.23428>:
        D.22484 = ctx.level;
        D.22485 = D.22484 & 128;
        if (D.22485 != 0) goto <D.23426>; else goto <D.23427>;
        <D.23426>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.23429 = monoeg_g_strdup_printf ("Constructor %s for type %s not calling base type ctor.", method_name, type);
          vinfo->info.message = D.23429;
          vinfo->exception_type = 4;
          D.22431 = ctx.list;
          D.23430 = monoeg_g_slist_prepend (D.22431, vinfo);
          ctx.list = D.23430;
        }
        ctx.verifiable = 0;
        D.22484 = ctx.level;
        D.22488 = D.22484 & 16;
        if (D.22488 != 0) goto <D.23431>; else goto <D.23432>;
        <D.23431>:
        ctx.valid = 0;
        <D.23432>:
        <D.23427>:
        <D.23414>:
        monoeg_g_free (method_name);
        monoeg_g_free (type);
      }
      <D.23412>:
      <D.23410>:
      <D.23405>:
      <D.23402>:
      cleanup:
      D.22466 = ctx.code;
      if (D.22466 != 0B) goto <D.23433>; else goto <D.23434>;
      <D.23433>:
      i = 0;
      goto <D.21997>;
      <D.21996>:
      D.22466 = ctx.code;
      i.12 = (unsigned int) i;
      D.23350 = i.12 * 12;
      D.23351 = D.22466 + D.23350;
      D.23435 = D.23351->stack;
      if (D.23435 != 0B) goto <D.23436>; else goto <D.23437>;
      <D.23436>:
      D.22466 = ctx.code;
      i.12 = (unsigned int) i;
      D.23350 = i.12 * 12;
      D.23351 = D.22466 + D.23350;
      D.23435 = D.23351->stack;
      monoeg_g_free (D.23435);
      <D.23437>:
      i = i + 1;
      <D.21997>:
      i.27 = (unsigned int) i;
      D.22449 = ctx.header;
      D.22454 = D.22449->code_size;
      if (i.27 < D.22454) goto <D.21996>; else goto <D.21998>;
      <D.21998>:
      <D.23434>:
      tmp = ctx.funptrs;
      goto <D.22000>;
      <D.21999>:
      D.23439 = tmp->data;
      monoeg_g_free (D.23439);
      tmp = tmp->next;
      <D.22000>:
      if (tmp != 0B) goto <D.21999>; else goto <D.22001>;
      <D.22001>:
      D.23440 = ctx.funptrs;
      monoeg_g_slist_free (D.23440);
      tmp = ctx.exception_types;
      goto <D.22003>;
      <D.22002>:
      D.23439 = tmp->data;
      mono_metadata_free_type (D.23439);
      tmp = tmp->next;
      <D.22003>:
      if (tmp != 0B) goto <D.22002>; else goto <D.22004>;
      <D.22004>:
      D.23441 = ctx.exception_types;
      monoeg_g_slist_free (D.23441);
      i = 0;
      goto <D.22006>;
      <D.22005>:
      D.22525 = ctx.locals;
      i.12 = (unsigned int) i;
      D.22527 = i.12 * 4;
      D.22528 = D.22525 + D.22527;
      D.22529 = *D.22528;
      if (D.22529 != 0B) goto <D.23442>; else goto <D.23443>;
      <D.23442>:
      D.22525 = ctx.locals;
      i.12 = (unsigned int) i;
      D.22527 = i.12 * 4;
      D.22528 = D.22525 + D.22527;
      D.22529 = *D.22528;
      mono_metadata_free_type (D.22529);
      <D.23443>:
      i = i + 1;
      <D.22006>:
      D.22473 = ctx.num_locals;
      if (D.22473 > i) goto <D.22005>; else goto <D.22007>;
      <D.22007>:
      i = 0;
      goto <D.22009>;
      <D.22008>:
      D.22499 = ctx.params;
      i.12 = (unsigned int) i;
      D.22527 = i.12 * 4;
      D.22541 = D.22499 + D.22527;
      D.22542 = *D.22541;
      if (D.22542 != 0B) goto <D.23444>; else goto <D.23445>;
      <D.23444>:
      D.22499 = ctx.params;
      i.12 = (unsigned int) i;
      D.22527 = i.12 * 4;
      D.22541 = D.22499 + D.22527;
      D.22542 = *D.22541;
      mono_metadata_free_type (D.22542);
      <D.23445>:
      i = i + 1;
      <D.22009>:
      D.22491 = ctx.max_args;
      if (D.22491 > i) goto <D.22008>; else goto <D.22010>;
      <D.22010>:
      D.23446 = ctx.eval.stack;
      if (D.23446 != 0B) goto <D.23447>; else goto <D.23448>;
      <D.23447>:
      D.23446 = ctx.eval.stack;
      monoeg_g_free (D.23446);
      <D.23448>:
      D.22466 = ctx.code;
      if (D.22466 != 0B) goto <D.23449>; else goto <D.23450>;
      <D.23449>:
      D.22466 = ctx.code;
      monoeg_g_free (D.22466);
      <D.23450>:
      D.22525 = ctx.locals;
      monoeg_g_free (D.22525);
      D.22499 = ctx.params;
      monoeg_g_free (D.22499);
      mono_basic_block_free (original_bb);
      D.22449 = ctx.header;
      mono_metadata_free_mh (D.22449);
      D.22425 = ctx.list;
      return D.22425;
    }
  finally
    {
      error = {CLOBBER};
      ctx = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.23457;
  int D.23462;
  void * D.23464;
  unsigned int D.23465;

  D.23457 = __builtin_constant_p (__len);
  if (D.23457 != 0) goto <D.23458>; else goto <D.23459>;
  <D.23458>:
  if (__len == 0) goto <D.23460>; else goto <D.23461>;
  <D.23460>:
  D.23462 = __builtin_constant_p (__ch);
  if (D.23462 == 0) goto <D.23455>; else goto <D.23463>;
  <D.23463>:
  if (__ch != 0) goto <D.23455>; else goto <D.23456>;
  <D.23455>:
  __warn_memset_zero_len ();
  D.23464 = __dest;
  return D.23464;
  <D.23456>:
  <D.23461>:
  <D.23459>:
  D.23465 = __builtin_object_size (__dest, 0);
  D.23464 = __builtin___memset_chk (__dest, __ch, __len, D.23465);
  return D.23464;
}


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

  D.23468 = __builtin_object_size (__dest, 0);
  D.23467 = __builtin___memcpy_chk (__dest, __src, __len, D.23468);
  return D.23467;
}


stack_init (struct VerifyContext * ctx, struct ILCodeDesc * state)
{
  short unsigned int D.23470;
  int D.23471;
  int D.23472;
  short unsigned int D.23475;
  short unsigned int D.23476;

  D.23470 = state->flags;
  D.23471 = (int) D.23470;
  D.23472 = D.23471 & 4;
  if (D.23472 != 0) goto <D.23473>; else goto <D.23474>;
  <D.23473>:
  return;
  <D.23474>:
  state->max_size = 0;
  D.23475 = state->max_size;
  state->size = D.23475;
  D.23470 = state->flags;
  D.23476 = D.23470 | 4;
  state->flags = D.23476;
}


get_stack_type (struct MonoType * type)
{
  unsigned char D.23478;
  unsigned char D.23479;
  unsigned char D.23480;
  int D.23483;
  int D.23484;
  int mask;
  int type_kind;
  void handle_enum = <<< error >>>;

  mask = 0;
  D.23478 = type->type;
  type_kind = (int) D.23478;
  D.23479 = BIT_FIELD_REF <*type, 8, 56>;
  D.23480 = D.23479 & 64;
  if (D.23480 != 0) goto <D.23481>; else goto <D.23482>;
  <D.23481>:
  mask = 256;
  <D.23482>:
  handle_enum:
  switch (type_kind) <default: <D.20601>, case 2: <D.20577>, case 3: <D.20580>, case 4: <D.20575>, case 5: <D.20576>, case 6: <D.20578>, case 7: <D.20579>, case 8: <D.20581>, case 9: <D.20582>, case 10: <D.20595>, case 11: <D.20596>, case 12: <D.20597>, case 13: <D.20598>, case 14: <D.20591>, case 15: <D.20586>, case 17: <D.20600>, case 18: <D.20590>, case 19: <D.20588>, case 20: <D.20594>, case 21: <D.20599>, case 22: <D.20587>, case 24: <D.20583>, case 25: <D.20584>, case 27: <D.20585>, case 28: <D.20592>, case 29: <D.20593>, case 30: <D.20589>>
  <D.20575>:
  <D.20576>:
  <D.20577>:
  <D.20578>:
  <D.20579>:
  <D.20580>:
  <D.20581>:
  <D.20582>:
  D.23483 = mask | 1;
  return D.23483;
  <D.20583>:
  <D.20584>:
  D.23483 = mask | 3;
  return D.23483;
  <D.20585>:
  <D.20586>:
  <D.20587>:
  D.23483 = mask | 5;
  return D.23483;
  <D.20588>:
  <D.20589>:
  <D.20590>:
  <D.20591>:
  <D.20592>:
  <D.20593>:
  <D.20594>:
  D.23483 = mask | 6;
  return D.23483;
  <D.20595>:
  <D.20596>:
  D.23483 = mask | 2;
  return D.23483;
  <D.20597>:
  <D.20598>:
  D.23483 = mask | 4;
  return D.23483;
  <D.20599>:
  <D.20600>:
  D.23484 = mono_type_is_enum_type (type);
  if (D.23484 != 0) goto <D.23485>; else goto <D.23486>;
  <D.23485>:
  type = mono_type_get_underlying_type_any (type);
  if (type == 0B) goto <D.23487>; else goto <D.23488>;
  <D.23487>:
  D.23483 = 0;
  return D.23483;
  <D.23488>:
  D.23478 = type->type;
  type_kind = (int) D.23478;
  goto handle_enum;
  <D.23486>:
  D.23483 = mask | 6;
  return D.23483;
  <D.20601>:
  D.23483 = 0;
  return D.23483;
}


mono_type_is_enum_type (struct MonoType * type)
{
  unsigned char D.23490;
  struct MonoClass * D.23493;
  unsigned char D.23494;
  unsigned char D.23495;
  gboolean D.23498;
  struct MonoGenericClass * D.23501;
  struct MonoClass * D.23502;
  unsigned char D.23503;
  unsigned char D.23504;

  D.23490 = type->type;
  if (D.23490 == 17) goto <D.23491>; else goto <D.23492>;
  <D.23491>:
  D.23493 = type->data.klass;
  D.23494 = BIT_FIELD_REF <*D.23493, 8, 160>;
  D.23495 = D.23494 & 16;
  if (D.23495 != 0) goto <D.23496>; else goto <D.23497>;
  <D.23496>:
  D.23498 = 1;
  return D.23498;
  <D.23497>:
  <D.23492>:
  D.23490 = type->type;
  if (D.23490 == 21) goto <D.23499>; else goto <D.23500>;
  <D.23499>:
  D.23501 = type->data.generic_class;
  D.23502 = D.23501->container_class;
  D.23503 = BIT_FIELD_REF <*D.23502, 8, 160>;
  D.23504 = D.23503 & 16;
  if (D.23504 != 0) goto <D.23505>; else goto <D.23506>;
  <D.23505>:
  D.23498 = 1;
  return D.23498;
  <D.23506>:
  <D.23500>:
  D.23498 = 0;
  return D.23498;
}


mono_type_get_underlying_type_any (struct MonoType * type)
{
  unsigned char D.23508;
  struct MonoClass * D.23511;
  unsigned char D.23512;
  unsigned char D.23513;
  struct MonoType * D.23516;
  struct MonoGenericClass * D.23519;
  struct MonoClass * D.23520;
  unsigned char D.23521;
  unsigned char D.23522;

  D.23508 = type->type;
  if (D.23508 == 17) goto <D.23509>; else goto <D.23510>;
  <D.23509>:
  D.23511 = type->data.klass;
  D.23512 = BIT_FIELD_REF <*D.23511, 8, 160>;
  D.23513 = D.23512 & 16;
  if (D.23513 != 0) goto <D.23514>; else goto <D.23515>;
  <D.23514>:
  D.23511 = type->data.klass;
  D.23516 = mono_class_enum_basetype (D.23511);
  return D.23516;
  <D.23515>:
  <D.23510>:
  D.23508 = type->type;
  if (D.23508 == 21) goto <D.23517>; else goto <D.23518>;
  <D.23517>:
  D.23519 = type->data.generic_class;
  D.23520 = D.23519->container_class;
  D.23521 = BIT_FIELD_REF <*D.23520, 8, 160>;
  D.23522 = D.23521 & 16;
  if (D.23522 != 0) goto <D.23523>; else goto <D.23524>;
  <D.23523>:
  D.23519 = type->data.generic_class;
  D.23520 = D.23519->container_class;
  D.23516 = mono_class_enum_basetype (D.23520);
  return D.23516;
  <D.23524>:
  <D.23518>:
  D.23516 = type;
  return D.23516;
}


verify_clause_relationship (struct VerifyContext * ctx, struct MonoExceptionClause * clause, struct MonoExceptionClause * to_test)
{
  unsigned int D.23526;
  unsigned int D.23529;
  unsigned int D.23530;
  int D.23531;
  gchar * D.23534;
  struct GSList * D.23535;
  struct GSList * D.23536;
  int D.23537;
  gchar * D.23540;
  struct GSList * D.23541;
  unsigned int D.23542;
  unsigned int D.23543;
  unsigned int D.23546;
  unsigned int D.23547;
  uint32_t iftmp.28;
  unsigned int D.23551;
  unsigned int D.23555;
  unsigned int D.23556;
  unsigned int D.23557;
  int D.23558;
  gchar * D.23561;
  struct GSList * D.23562;
  gchar * D.23566;
  struct GSList * D.23567;
  unsigned int D.23570;
  int D.23571;
  uint32_t iftmp.29;
  int D.23577;
  int D.23578;
  gchar * D.23581;
  struct GSList * D.23582;

  D.23526 = to_test->flags;
  if (D.23526 == 1) goto <D.23527>; else goto <D.23528>;
  <D.23527>:
  D.23529 = to_test->data.filter_offset;
  D.23530 = to_test->handler_offset;
  D.23531 = is_clause_inside_range (clause, D.23529, D.23530);
  if (D.23531 != 0) goto <D.23532>; else goto <D.23533>;
  <D.23532>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.23534 = monoeg_g_strdup_printf ("Exception clause inside filter");
    vinfo->info.message = D.23534;
    vinfo->exception_type = 3;
    D.23535 = ctx->list;
    D.23536 = monoeg_g_slist_prepend (D.23535, vinfo);
    ctx->list = D.23536;
  }
  ctx->valid = 0;
  return;
  <D.23533>:
  <D.23528>:
  D.23537 = is_clause_nested (clause, to_test);
  if (D.23537 != 0) goto <D.23538>; else goto <D.23539>;
  <D.23538>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.23540 = monoeg_g_strdup_printf ("Nested exception clause appears after enclosing clause");
    vinfo->info.message = D.23540;
    vinfo->exception_type = 3;
    D.23535 = ctx->list;
    D.23541 = monoeg_g_slist_prepend (D.23535, vinfo);
    ctx->list = D.23541;
  }
  ctx->valid = 0;
  return;
  <D.23539>:
  D.23542 = clause->try_offset;
  D.23543 = to_test->try_offset;
  if (D.23542 == D.23543) goto <D.23544>; else goto <D.23545>;
  <D.23544>:
  D.23546 = clause->try_len;
  D.23547 = to_test->try_len;
  if (D.23546 == D.23547) goto <D.23548>; else goto <D.23549>;
  <D.23548>:
  D.23551 = clause->flags;
  if (D.23551 == 1) goto <D.23552>; else goto <D.23553>;
  <D.23552>:
  iftmp.28 = clause->data.filter_offset;
  goto <D.23554>;
  <D.23553>:
  iftmp.28 = clause->handler_offset;
  <D.23554>:
  D.23555 = clause->handler_offset;
  D.23556 = clause->handler_len;
  D.23557 = D.23555 + D.23556;
  D.23558 = is_clause_in_range (to_test, iftmp.28, D.23557);
  if (D.23558 != 0) goto <D.23559>; else goto <D.23560>;
  <D.23559>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.23561 = monoeg_g_strdup_printf ("Exception handlers overlap");
    vinfo->info.message = D.23561;
    vinfo->exception_type = 3;
    D.23535 = ctx->list;
    D.23562 = monoeg_g_slist_prepend (D.23535, vinfo);
    ctx->list = D.23562;
  }
  ctx->valid = 0;
  return;
  <D.23560>:
  D.23551 = clause->flags;
  if (D.23551 > 1) goto <D.23563>; else goto <D.23565>;
  <D.23565>:
  D.23526 = to_test->flags;
  if (D.23526 > 1) goto <D.23563>; else goto <D.23564>;
  <D.23563>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.23566 = monoeg_g_strdup_printf ("Exception clauses with shared protected block are neither catch or filter");
    vinfo->info.message = D.23566;
    vinfo->exception_type = 3;
    D.23535 = ctx->list;
    D.23567 = monoeg_g_slist_prepend (D.23535, vinfo);
    ctx->list = D.23567;
  }
  ctx->valid = 0;
  return;
  <D.23564>:
  return;
  <D.23549>:
  <D.23545>:
  D.23542 = clause->try_offset;
  D.23542 = clause->try_offset;
  D.23546 = clause->try_len;
  D.23570 = D.23542 + D.23546;
  D.23571 = is_clause_in_range (to_test, D.23542, D.23570);
  if (D.23571 != 0) goto <D.23568>; else goto <D.23572>;
  <D.23572>:
  D.23551 = clause->flags;
  if (D.23551 == 1) goto <D.23574>; else goto <D.23575>;
  <D.23574>:
  iftmp.29 = clause->data.filter_offset;
  goto <D.23576>;
  <D.23575>:
  iftmp.29 = clause->handler_offset;
  <D.23576>:
  D.23555 = clause->handler_offset;
  D.23556 = clause->handler_len;
  D.23557 = D.23555 + D.23556;
  D.23577 = is_clause_in_range (to_test, iftmp.29, D.23557);
  if (D.23577 != 0) goto <D.23568>; else goto <D.23569>;
  <D.23568>:
  D.23578 = is_clause_nested (to_test, clause);
  if (D.23578 == 0) goto <D.23579>; else goto <D.23580>;
  <D.23579>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.23581 = monoeg_g_strdup_printf ("Exception clauses overlap");
    vinfo->info.message = D.23581;
    vinfo->exception_type = 3;
    D.23535 = ctx->list;
    D.23582 = monoeg_g_slist_prepend (D.23535, vinfo);
    ctx->list = D.23582;
  }
  ctx->valid = 0;
  <D.23580>:
  <D.23569>:
}


is_clause_inside_range (struct MonoExceptionClause * clause, guint32 start, guint32 end)
{
  unsigned int D.23586;
  unsigned int D.23588;
  unsigned int D.23589;
  gboolean D.23590;
  uint32_t iftmp.30;
  unsigned int D.23594;
  unsigned int D.23599;
  unsigned int D.23600;
  unsigned int D.23601;

  D.23586 = clause->try_offset;
  if (D.23586 < start) goto <D.23584>; else goto <D.23587>;
  <D.23587>:
  D.23586 = clause->try_offset;
  D.23588 = clause->try_len;
  D.23589 = D.23586 + D.23588;
  if (D.23589 > end) goto <D.23584>; else goto <D.23585>;
  <D.23584>:
  D.23590 = 0;
  return D.23590;
  <D.23585>:
  D.23594 = clause->flags;
  if (D.23594 == 1) goto <D.23595>; else goto <D.23596>;
  <D.23595>:
  iftmp.30 = clause->data.filter_offset;
  goto <D.23597>;
  <D.23596>:
  iftmp.30 = clause->handler_offset;
  <D.23597>:
  if (iftmp.30 < start) goto <D.23591>; else goto <D.23598>;
  <D.23598>:
  D.23599 = clause->handler_offset;
  D.23600 = clause->handler_len;
  D.23601 = D.23599 + D.23600;
  if (D.23601 > end) goto <D.23591>; else goto <D.23592>;
  <D.23591>:
  D.23590 = 0;
  return D.23590;
  <D.23592>:
  D.23590 = 1;
  return D.23590;
}


is_clause_in_range (struct MonoExceptionClause * clause, guint32 start, guint32 end)
{
  unsigned int D.23603;
  gboolean D.23608;
  uint32_t iftmp.31;
  unsigned int D.23610;
  uint32_t iftmp.32;

  D.23603 = clause->try_offset;
  if (D.23603 >= start) goto <D.23604>; else goto <D.23605>;
  <D.23604>:
  D.23603 = clause->try_offset;
  if (D.23603 < end) goto <D.23606>; else goto <D.23607>;
  <D.23606>:
  D.23608 = 1;
  return D.23608;
  <D.23607>:
  <D.23605>:
  D.23610 = clause->flags;
  if (D.23610 == 1) goto <D.23611>; else goto <D.23612>;
  <D.23611>:
  iftmp.31 = clause->data.filter_offset;
  goto <D.23613>;
  <D.23612>:
  iftmp.31 = clause->handler_offset;
  <D.23613>:
  if (iftmp.31 >= start) goto <D.23614>; else goto <D.23615>;
  <D.23614>:
  D.23610 = clause->flags;
  if (D.23610 == 1) goto <D.23617>; else goto <D.23618>;
  <D.23617>:
  iftmp.32 = clause->data.filter_offset;
  goto <D.23619>;
  <D.23618>:
  iftmp.32 = clause->handler_offset;
  <D.23619>:
  if (iftmp.32 < end) goto <D.23620>; else goto <D.23621>;
  <D.23620>:
  D.23608 = 1;
  return D.23608;
  <D.23621>:
  <D.23615>:
  D.23608 = 0;
  return D.23608;
}


is_clause_nested (struct MonoExceptionClause * clause, struct MonoExceptionClause * nested)
{
  unsigned int D.23623;
  unsigned int D.23626;
  unsigned int D.23627;
  int D.23628;
  gboolean D.23631;
  int iftmp.33;
  unsigned int D.23636;
  unsigned int D.23637;
  unsigned int D.23638;
  int D.23639;
  unsigned int D.23641;
  unsigned int D.23642;
  int D.23643;

  D.23623 = clause->flags;
  if (D.23623 == 1) goto <D.23624>; else goto <D.23625>;
  <D.23624>:
  D.23626 = clause->data.filter_offset;
  D.23627 = clause->handler_offset;
  D.23628 = is_clause_inside_range (nested, D.23626, D.23627);
  if (D.23628 != 0) goto <D.23629>; else goto <D.23630>;
  <D.23629>:
  D.23631 = 1;
  return D.23631;
  <D.23630>:
  <D.23625>:
  D.23636 = clause->try_offset;
  D.23636 = clause->try_offset;
  D.23637 = clause->try_len;
  D.23638 = D.23636 + D.23637;
  D.23639 = is_clause_inside_range (nested, D.23636, D.23638);
  if (D.23639 != 0) goto <D.23633>; else goto <D.23640>;
  <D.23640>:
  D.23627 = clause->handler_offset;
  D.23627 = clause->handler_offset;
  D.23641 = clause->handler_len;
  D.23642 = D.23627 + D.23641;
  D.23643 = is_clause_inside_range (nested, D.23627, D.23642);
  if (D.23643 != 0) goto <D.23633>; else goto <D.23634>;
  <D.23633>:
  iftmp.33 = 1;
  goto <D.23635>;
  <D.23634>:
  iftmp.33 = 0;
  <D.23635>:
  D.23631 = iftmp.33;
  return D.23631;
}


mono_type_is_valid_in_context (struct VerifyContext * ctx, struct MonoType * type)
{
  unsigned int D.23647;
  gchar * D.23648;
  struct GSList * D.23649;
  struct GSList * D.23650;
  gboolean D.23651;
  int D.23652;
  const char * iftmp.34;
  char D.23656;
  const char * iftmp.35;
  unsigned char D.23660;
  const char * iftmp.36;
  gchar * D.23669;
  struct GSList * D.23670;
  struct MonoLoaderError * D.23673;
  unsigned char D.23675;
  struct MonoGenericClass * D.23678;
  int D.23680;
  const char * D.23682;
  const char * D.23683;
  gchar * D.23684;
  struct GSList * D.23685;
  gchar * D.23686;
  struct GSList * D.23687;
  struct MonoClass * D.23690;
  unsigned char D.23691;
  gchar * D.23694;
  struct GSList * D.23695;
  int D.23698;
  gchar * D.23701;
  struct GSList * D.23702;
  int D.23703;
  gchar * D.23706;
  struct GSList * D.23707;
  struct MonoClass * klass;

  if (type == 0B) goto <D.23645>; else goto <D.23646>;
  <D.23645>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.23647 = ctx->ip_offset;
    D.23648 = monoeg_g_strdup_printf ("Invalid null type at 0x%04x", D.23647);
    vinfo->info.message = D.23648;
    vinfo->exception_type = 12;
    D.23649 = ctx->list;
    D.23650 = monoeg_g_slist_prepend (D.23649, vinfo);
    ctx->list = D.23650;
  }
  ctx->valid = 0;
  D.23651 = 0;
  return D.23651;
  <D.23646>:
  D.23652 = is_valid_type_in_context (ctx, type);
  if (D.23652 == 0) goto <D.23653>; else goto <D.23654>;
  <D.23653>:
  {
    char * str;

    str = mono_type_full_name (type);
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.23656 = *str;
      if (D.23656 != 33) goto <D.23657>; else goto <D.23658>;
      <D.23657>:
      D.23660 = type->type;
      if (D.23660 == 19) goto <D.23661>; else goto <D.23662>;
      <D.23661>:
      iftmp.35 = "!";
      goto <D.23663>;
      <D.23662>:
      iftmp.35 = "!!";
      <D.23663>:
      iftmp.34 = iftmp.35;
      goto <D.23664>;
      <D.23658>:
      iftmp.34 = "";
      <D.23664>:
      D.23660 = type->type;
      if (D.23660 == 19) goto <D.23666>; else goto <D.23667>;
      <D.23666>:
      iftmp.36 = "class";
      goto <D.23668>;
      <D.23667>:
      iftmp.36 = "method";
      <D.23668>:
      D.23647 = ctx->ip_offset;
      D.23669 = monoeg_g_strdup_printf ("Invalid generic type (%s%s) (argument out of range or %s is not generic) at 0x%04x", iftmp.34, str, iftmp.36, D.23647);
      vinfo->info.message = D.23669;
      vinfo->exception_type = 12;
      D.23649 = ctx->list;
      D.23670 = monoeg_g_slist_prepend (D.23649, vinfo);
      ctx->list = D.23670;
    }
    ctx->valid = 0;
    monoeg_g_free (str);
    D.23651 = 0;
    return D.23651;
  }
  <D.23654>:
  klass = mono_class_from_mono_type (type);
  mono_class_init (klass);
  D.23673 = mono_loader_get_last_error ();
  if (D.23673 != 0B) goto <D.23671>; else goto <D.23674>;
  <D.23674>:
  D.23675 = klass->exception_type;
  if (D.23675 != 0) goto <D.23671>; else goto <D.23672>;
  <D.23671>:
  D.23678 = klass->generic_class;
  if (D.23678 != 0B) goto <D.23679>; else goto <D.23676>;
  <D.23679>:
  D.23680 = mono_class_is_valid_generic_instantiation (0B, klass);
  if (D.23680 == 0) goto <D.23681>; else goto <D.23676>;
  <D.23681>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.23682 = klass->name_space;
    D.23683 = klass->name;
    D.23647 = ctx->ip_offset;
    D.23684 = monoeg_g_strdup_printf ("Invalid generic instantiation of type %s.%s at 0x%04x", D.23682, D.23683, D.23647);
    vinfo->info.message = D.23684;
    vinfo->exception_type = 7;
    D.23649 = ctx->list;
    D.23685 = monoeg_g_slist_prepend (D.23649, vinfo);
    ctx->list = D.23685;
  }
  ctx->valid = 0;
  goto <D.23677>;
  <D.23676>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.23682 = klass->name_space;
    D.23683 = klass->name;
    D.23647 = ctx->ip_offset;
    D.23686 = monoeg_g_strdup_printf ("Could not load type %s.%s at 0x%04x", D.23682, D.23683, D.23647);
    vinfo->info.message = D.23686;
    vinfo->exception_type = 7;
    D.23649 = ctx->list;
    D.23687 = monoeg_g_slist_prepend (D.23649, vinfo);
    ctx->list = D.23687;
  }
  ctx->valid = 0;
  <D.23677>:
  mono_loader_clear_error ();
  D.23651 = 0;
  return D.23651;
  <D.23672>:
  D.23678 = klass->generic_class;
  if (D.23678 != 0B) goto <D.23688>; else goto <D.23689>;
  <D.23688>:
  D.23678 = klass->generic_class;
  D.23690 = D.23678->container_class;
  D.23691 = D.23690->exception_type;
  if (D.23691 != 0) goto <D.23692>; else goto <D.23693>;
  <D.23692>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.23682 = klass->name_space;
    D.23683 = klass->name;
    D.23647 = ctx->ip_offset;
    D.23694 = monoeg_g_strdup_printf ("Could not load type %s.%s at 0x%04x", D.23682, D.23683, D.23647);
    vinfo->info.message = D.23694;
    vinfo->exception_type = 7;
    D.23649 = ctx->list;
    D.23695 = monoeg_g_slist_prepend (D.23649, vinfo);
    ctx->list = D.23695;
  }
  ctx->valid = 0;
  D.23651 = 0;
  return D.23651;
  <D.23693>:
  <D.23689>:
  D.23678 = klass->generic_class;
  if (D.23678 == 0B) goto <D.23696>; else goto <D.23697>;
  <D.23696>:
  D.23651 = 1;
  return D.23651;
  <D.23697>:
  D.23698 = mono_class_is_valid_generic_instantiation (ctx, klass);
  if (D.23698 == 0) goto <D.23699>; else goto <D.23700>;
  <D.23699>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.23682 = klass->name_space;
    D.23683 = klass->name;
    D.23647 = ctx->ip_offset;
    D.23701 = monoeg_g_strdup_printf ("Invalid generic type instantiation of type %s.%s at 0x%04x", D.23682, D.23683, D.23647);
    vinfo->info.message = D.23701;
    vinfo->exception_type = 7;
    D.23649 = ctx->list;
    D.23702 = monoeg_g_slist_prepend (D.23649, vinfo);
    ctx->list = D.23702;
  }
  ctx->valid = 0;
  D.23651 = 0;
  return D.23651;
  <D.23700>:
  D.23703 = mono_class_repect_method_constraints (ctx, klass);
  if (D.23703 == 0) goto <D.23704>; else goto <D.23705>;
  <D.23704>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.23682 = klass->name_space;
    D.23683 = klass->name;
    D.23647 = ctx->ip_offset;
    D.23706 = monoeg_g_strdup_printf ("Invalid generic type instantiation of type %s.%s (generic args don\'t respect target\'s constraints) at 0x%04x", D.23682, D.23683, D.23647);
    vinfo->info.message = D.23706;
    vinfo->exception_type = 7;
    D.23649 = ctx->list;
    D.23707 = monoeg_g_slist_prepend (D.23649, vinfo);
    ctx->list = D.23707;
  }
  ctx->valid = 0;
  D.23651 = 0;
  return D.23651;
  <D.23705>:
  D.23651 = 1;
  return D.23651;
}


is_valid_type_in_context (struct VerifyContext * ctx, struct MonoType * type)
{
  gboolean D.23709;
  struct MonoGenericContext * D.23710;

  D.23710 = ctx->generic_context;
  D.23709 = mono_type_is_valid_type_in_context (type, D.23710);
  return D.23709;
}


mono_type_is_valid_type_in_context (struct MonoType * type, struct MonoGenericContext * context)
{
  gboolean D.23712;

  D.23712 = mono_type_is_valid_type_in_context_full (type, context, 0);
  return D.23712;
}


mono_type_is_valid_type_in_context_full (struct MonoType * type, struct MonoGenericContext * context, gboolean check_gtd)
{
  unsigned char D.23714;
  int D.23715;
  gboolean D.23718;
  struct MonoGenericInst * iftmp.37;
  struct MonoGenericParam * D.23726;
  short unsigned int D.23727;
  int D.23728;
  <unnamed-unsigned:22> D.23729;
  int D.23730;
  struct MonoClass * D.23731;
  struct MonoType * D.23732;
  struct MonoArrayType * D.23733;
  struct MonoClass * D.23734;
  struct MonoType * D.23735;
  struct MonoType * D.23736;
  struct MonoGenericClass * D.23737;
  unsigned char D.23738;
  unsigned char D.23739;
  struct MonoType * D.23741;
  int D.23742;
  unsigned char D.23745;
  struct MonoType * D.23748;
  struct MonoGenericContainer * D.23751;
  int i;
  struct MonoGenericInst * inst;

  D.23714 = type->type;
  D.23715 = (int) D.23714;
  switch (D.23715) <default: <D.23754>, case 15: <D.20138>, case 17: <D.20144>, case 18: <D.20143>, case 19: <D.20133>, case 20: <D.20137>, case 21: <D.20139>, case 29: <D.20136>, case 30: <D.20134>>
  <D.20133>:
  <D.20134>:
  if (context == 0B) goto <D.23716>; else goto <D.23717>;
  <D.23716>:
  D.23718 = 0;
  return D.23718;
  <D.23717>:
  D.23714 = type->type;
  if (D.23714 == 19) goto <D.23720>; else goto <D.23721>;
  <D.23720>:
  iftmp.37 = context->class_inst;
  goto <D.23722>;
  <D.23721>:
  iftmp.37 = context->method_inst;
  <D.23722>:
  inst = iftmp.37;
  if (inst == 0B) goto <D.23723>; else goto <D.23725>;
  <D.23725>:
  D.23726 = type->data.generic_param;
  D.23727 = D.23726->num;
  D.23728 = (int) D.23727;
  D.23729 = inst->type_argc;
  D.23730 = (int) D.23729;
  if (D.23728 >= D.23730) goto <D.23723>; else goto <D.23724>;
  <D.23723>:
  D.23718 = 0;
  return D.23718;
  <D.23724>:
  goto <D.20135>;
  <D.20136>:
  D.23731 = type->data.klass;
  D.23732 = &D.23731->byval_arg;
  D.23718 = mono_type_is_valid_type_in_context_full (D.23732, context, check_gtd);
  return D.23718;
  <D.20137>:
  D.23733 = type->data.array;
  D.23734 = D.23733->eklass;
  D.23735 = &D.23734->byval_arg;
  D.23718 = mono_type_is_valid_type_in_context_full (D.23735, context, check_gtd);
  return D.23718;
  <D.20138>:
  D.23736 = type->data.type;
  D.23718 = mono_type_is_valid_type_in_context_full (D.23736, context, check_gtd);
  return D.23718;
  <D.20139>:
  D.23737 = type->data.generic_class;
  inst = D.23737->context.class_inst;
  D.23738 = BIT_FIELD_REF <*inst, 8, 48>;
  D.23739 = D.23738 & 64;
  if (D.23739 == 0) goto <D.20135>; else goto <D.23740>;
  <D.23740>:
  i = 0;
  goto <D.20141>;
  <D.20140>:
  D.23741 = inst->type_argv[i];
  D.23742 = mono_type_is_valid_type_in_context_full (D.23741, context, check_gtd);
  if (D.23742 == 0) goto <D.23743>; else goto <D.23744>;
  <D.23743>:
  D.23718 = 0;
  return D.23718;
  <D.23744>:
  i = i + 1;
  <D.20141>:
  D.23729 = inst->type_argc;
  D.23730 = (int) D.23729;
  if (D.23730 > i) goto <D.20140>; else goto <D.20142>;
  <D.20142>:
  goto <D.20135>;
  <D.20143>:
  <D.20144>:
  {
    struct MonoClass * klass;

    klass = type->data.klass;
    D.23745 = klass->byval_arg.type;
    D.23714 = type->type;
    if (D.23745 != D.23714) goto <D.23746>; else goto <D.23747>;
    <D.23746>:
    D.23748 = &klass->byval_arg;
    D.23718 = mono_type_is_valid_type_in_context_full (D.23748, context, check_gtd);
    return D.23718;
    <D.23747>:
    if (check_gtd != 0) goto <D.23749>; else goto <D.23750>;
    <D.23749>:
    D.23751 = klass->generic_container;
    if (D.23751 != 0B) goto <D.23752>; else goto <D.23753>;
    <D.23752>:
    D.23718 = 0;
    return D.23718;
    <D.23753>:
    <D.23750>:
    goto <D.20135>;
  }
  <D.23754>:
  <D.20135>:
  D.23718 = 1;
  return D.23718;
}


mono_class_is_valid_generic_instantiation (struct VerifyContext * ctx, struct MonoClass * klass)
{
  struct MonoClass * D.23756;
  int D.23759;
  gboolean D.23762;
  struct MonoGenericContext * D.23763;
  struct MonoGenericClass * gklass;
  struct MonoGenericInst * ginst;
  struct MonoGenericContainer * gc;

  gklass = klass->generic_class;
  ginst = gklass->context.class_inst;
  D.23756 = gklass->container_class;
  gc = D.23756->generic_container;
  if (ctx != 0B) goto <D.23757>; else goto <D.23758>;
  <D.23757>:
  D.23759 = is_valid_generic_instantiation_in_context (ctx, ginst, 1);
  if (D.23759 == 0) goto <D.23760>; else goto <D.23761>;
  <D.23760>:
  D.23762 = 0;
  return D.23762;
  <D.23761>:
  <D.23758>:
  D.23763 = &gklass->context;
  D.23762 = is_valid_generic_instantiation (gc, D.23763, ginst);
  return D.23762;
}


is_valid_generic_instantiation_in_context (struct VerifyContext * ctx, struct MonoGenericInst * ginst, gboolean check_gtd)
{
  struct MonoGenericContext * D.23765;
  int D.23766;
  gboolean D.23769;
  <unnamed-unsigned:22> D.23770;
  int D.23771;
  int i;

  i = 0;
  goto <D.20229>;
  <D.20228>:
  {
    struct MonoType * type;

    type = ginst->type_argv[i];
    D.23765 = ctx->generic_context;
    D.23766 = mono_type_is_valid_type_in_context_full (type, D.23765, 1);
    if (D.23766 == 0) goto <D.23767>; else goto <D.23768>;
    <D.23767>:
    D.23769 = 0;
    return D.23769;
    <D.23768>:
  }
  i = i + 1;
  <D.20229>:
  D.23770 = ginst->type_argc;
  D.23771 = (int) D.23770;
  if (D.23771 > i) goto <D.20228>; else goto <D.20230>;
  <D.20230>:
  D.23769 = 1;
  return D.23769;
}


is_valid_generic_instantiation (struct MonoGenericContainer * gc, struct MonoGenericContext * context, struct MonoGenericInst * ginst)
{
  <unnamed-unsigned:22> D.23773;
  int D.23774;
  <unnamed-signed:31> D.23775;
  int D.23776;
  gboolean D.23779;
  struct MonoGenericParamFull * D.23780;
  unsigned int i.38;
  unsigned int D.23782;
  struct MonoGenericParamFull * D.23783;
  int D.23784;
  struct MonoGenericContainer * D.23787;
  unsigned char D.23790;
  unsigned char D.23793;
  unsigned char D.23794;
  struct MonoGenericClass * D.23797;
  unsigned char D.23800;
  unsigned char D.23801;
  int D.23804;
  struct MonoClass * * D.23807;
  short unsigned int D.23810;
  int D.23811;
  int D.23812;
  int D.23817;
  unsigned char D.23820;
  int D.23822;
  int D.23823;
  int D.23828;
  int D.23833;
  struct MonoType * D.23838;
  int D.23839;
  int D.23842;
  struct MonoClass * D.23845;
  struct MonoError error;
  int i;

  try
    {
      D.23773 = ginst->type_argc;
      D.23774 = (int) D.23773;
      D.23775 = gc->type_argc;
      D.23776 = (int) D.23775;
      if (D.23774 != D.23776) goto <D.23777>; else goto <D.23778>;
      <D.23777>:
      D.23779 = 0;
      return D.23779;
      <D.23778>:
      i = 0;
      goto <D.20175>;
      <D.20174>:
      {
        struct MonoGenericParamInfo * param_info;
        struct MonoClass * paramClass;
        struct MonoClass * * constraints;
        struct MonoType * param_type;

        D.23780 = gc->type_params;
        i.38 = (unsigned int) i;
        D.23782 = i.38 * 32;
        D.23783 = D.23780 + D.23782;
        param_info = &D.23783->info;
        param_type = ginst->type_argv[i];
        D.23784 = mono_type_is_generic_argument (param_type);
        if (D.23784 != 0) goto <D.23785>; else goto <D.23786>;
        <D.23785>:
        // predicted unlikely by continue predictor.
        goto <D.20168>;
        <D.23786>:
        paramClass = mono_class_from_mono_type (param_type);
        D.23787 = paramClass->generic_container;
        if (D.23787 != 0B) goto <D.23788>; else goto <D.23789>;
        <D.23788>:
        D.23790 = param_type->type;
        if (D.23790 != 21) goto <D.23791>; else goto <D.23792>;
        <D.23791>:
        D.23793 = BIT_FIELD_REF <*ginst, 8, 48>;
        D.23794 = D.23793 & 64;
        if (D.23794 == 0) goto <D.23795>; else goto <D.23796>;
        <D.23795>:
        D.23779 = 0;
        return D.23779;
        <D.23796>:
        <D.23792>:
        <D.23789>:
        D.23797 = paramClass->generic_class;
        if (D.23797 != 0B) goto <D.23798>; else goto <D.23799>;
        <D.23798>:
        D.23800 = BIT_FIELD_REF <*paramClass, 8, 160>;
        D.23801 = D.23800 & 1;
        if (D.23801 == 0) goto <D.23802>; else goto <D.23803>;
        <D.23802>:
        D.23804 = mono_class_is_valid_generic_instantiation (0B, paramClass);
        if (D.23804 == 0) goto <D.23805>; else goto <D.23806>;
        <D.23805>:
        D.23779 = 0;
        return D.23779;
        <D.23806>:
        <D.23803>:
        <D.23799>:
        D.23807 = param_info->constraints;
        if (D.23807 == 0B) goto <D.23808>; else goto <D.23809>;
        <D.23808>:
        D.23810 = param_info->flags;
        D.23811 = (int) D.23810;
        D.23812 = D.23811 & 28;
        if (D.23812 == 0) goto <D.23813>; else goto <D.23814>;
        <D.23813>:
        // predicted unlikely by continue predictor.
        goto <D.20168>;
        <D.23814>:
        <D.23809>:
        D.23810 = param_info->flags;
        D.23811 = (int) D.23810;
        D.23817 = D.23811 & 8;
        if (D.23817 != 0) goto <D.23818>; else goto <D.23819>;
        <D.23818>:
        D.23800 = BIT_FIELD_REF <*paramClass, 8, 160>;
        D.23820 = D.23800 & 8;
        if (D.23820 == 0) goto <D.23815>; else goto <D.23821>;
        <D.23821>:
        D.23822 = mono_class_is_nullable (paramClass);
        if (D.23822 != 0) goto <D.23815>; else goto <D.23816>;
        <D.23815>:
        D.23779 = 0;
        return D.23779;
        <D.23816>:
        <D.23819>:
        D.23810 = param_info->flags;
        D.23811 = (int) D.23810;
        D.23823 = D.23811 & 4;
        if (D.23823 != 0) goto <D.23824>; else goto <D.23825>;
        <D.23824>:
        D.23800 = BIT_FIELD_REF <*paramClass, 8, 160>;
        D.23820 = D.23800 & 8;
        if (D.23820 != 0) goto <D.23826>; else goto <D.23827>;
        <D.23826>:
        D.23779 = 0;
        return D.23779;
        <D.23827>:
        <D.23825>:
        D.23810 = param_info->flags;
        D.23811 = (int) D.23810;
        D.23828 = D.23811 & 16;
        if (D.23828 != 0) goto <D.23829>; else goto <D.23830>;
        <D.23829>:
        D.23800 = BIT_FIELD_REF <*paramClass, 8, 160>;
        D.23820 = D.23800 & 8;
        if (D.23820 == 0) goto <D.23831>; else goto <D.23832>;
        <D.23831>:
        D.23833 = mono_class_has_default_constructor (paramClass);
        if (D.23833 == 0) goto <D.23834>; else goto <D.23835>;
        <D.23834>:
        D.23779 = 0;
        return D.23779;
        <D.23835>:
        <D.23832>:
        <D.23830>:
        D.23807 = param_info->constraints;
        if (D.23807 == 0B) goto <D.23836>; else goto <D.23837>;
        <D.23836>:
        // predicted unlikely by continue predictor.
        goto <D.20168>;
        <D.23837>:
        constraints = param_info->constraints;
        goto <D.20172>;
        <D.20171>:
        {
          struct MonoClass * ctr;
          struct MonoType * inflated;

          ctr = *constraints;
          D.23838 = &ctr->byval_arg;
          inflated = mono_class_inflate_generic_type_checked (D.23838, context, &error);
          D.23839 = mono_error_ok (&error);
          if (D.23839 == 0) goto <D.23840>; else goto <D.23841>;
          <D.23840>:
          mono_error_cleanup (&error);
          D.23779 = 0;
          return D.23779;
          <D.23841>:
          ctr = mono_class_from_mono_type (inflated);
          mono_metadata_free_type (inflated);
          D.23842 = mono_class_is_assignable_from_slow (ctr, paramClass);
          if (D.23842 == 0) goto <D.23843>; else goto <D.23844>;
          <D.23843>:
          D.23779 = 0;
          return D.23779;
          <D.23844>:
        }
        constraints = constraints + 4;
        <D.20172>:
        D.23845 = *constraints;
        if (D.23845 != 0B) goto <D.20171>; else goto <D.20173>;
        <D.20173>:
      }
      <D.20168>:
      i = i + 1;
      <D.20175>:
      D.23775 = gc->type_argc;
      D.23776 = (int) D.23775;
      if (D.23776 > i) goto <D.20174>; else goto <D.20176>;
      <D.20176>:
      D.23779 = 1;
      return D.23779;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_type_is_generic_argument (struct MonoType * type)
{
  gboolean D.23848;
  unsigned char D.23849;
  _Bool D.23850;
  _Bool D.23851;
  _Bool D.23852;

  D.23849 = type->type;
  D.23850 = D.23849 == 19;
  D.23851 = D.23849 == 30;
  D.23852 = D.23850 | D.23851;
  D.23848 = (gboolean) D.23852;
  return D.23848;
}


mono_class_has_default_constructor (struct MonoClass * klass)
{
  unsigned char D.23854;
  gboolean D.23857;
  struct MonoMethod * * D.23858;
  unsigned int i.39;
  unsigned int D.23860;
  struct MonoMethod * * D.23861;
  int D.23862;
  struct MonoMethodSignature * D.23865;
  struct MonoMethodSignature * D.23868;
  short unsigned int D.23869;
  short unsigned int D.23872;
  int D.23873;
  int D.23874;
  unsigned int i.40;
  unsigned int D.23878;
  struct MonoMethod * method;
  int i;

  mono_class_setup_methods (klass);
  D.23854 = klass->exception_type;
  if (D.23854 != 0) goto <D.23855>; else goto <D.23856>;
  <D.23855>:
  D.23857 = 0;
  return D.23857;
  <D.23856>:
  i = 0;
  goto <D.20124>;
  <D.20123>:
  D.23858 = klass->methods;
  i.39 = (unsigned int) i;
  D.23860 = i.39 * 4;
  D.23861 = D.23858 + D.23860;
  method = *D.23861;
  D.23862 = mono_method_is_constructor (method);
  if (D.23862 != 0) goto <D.23863>; else goto <D.23864>;
  <D.23863>:
  D.23865 = mono_method_signature (method);
  if (D.23865 != 0B) goto <D.23866>; else goto <D.23867>;
  <D.23866>:
  D.23868 = mono_method_signature (method);
  D.23869 = D.23868->param_count;
  if (D.23869 == 0) goto <D.23870>; else goto <D.23871>;
  <D.23870>:
  D.23872 = method->flags;
  D.23873 = (int) D.23872;
  D.23874 = D.23873 & 7;
  if (D.23874 == 6) goto <D.23875>; else goto <D.23876>;
  <D.23875>:
  D.23857 = 1;
  return D.23857;
  <D.23876>:
  <D.23871>:
  <D.23867>:
  <D.23864>:
  i = i + 1;
  <D.20124>:
  i.40 = (unsigned int) i;
  D.23878 = klass->method.count;
  if (i.40 < D.23878) goto <D.20123>; else goto <D.20125>;
  <D.20125>:
  D.23857 = 0;
  return D.23857;
}


mono_class_repect_method_constraints (struct VerifyContext * ctx, struct MonoClass * klass)
{
  struct MonoClass * D.23880;
  gboolean D.23881;
  int iftmp.41;
  struct MonoGenericContext * D.23887;
  int D.23888;
  struct MonoGenericClass * gklass;
  struct MonoGenericInst * ginst;
  struct MonoGenericContainer * gc;

  gklass = klass->generic_class;
  ginst = gklass->context.class_inst;
  D.23880 = gklass->container_class;
  gc = D.23880->generic_container;
  if (gc == 0B) goto <D.23883>; else goto <D.23886>;
  <D.23886>:
  D.23887 = &gklass->context;
  D.23888 = generic_arguments_respect_constraints (ctx, gc, D.23887, ginst);
  if (D.23888 != 0) goto <D.23883>; else goto <D.23884>;
  <D.23883>:
  iftmp.41 = 1;
  goto <D.23885>;
  <D.23884>:
  iftmp.41 = 0;
  <D.23885>:
  D.23881 = iftmp.41;
  return D.23881;
}


generic_arguments_respect_constraints (struct VerifyContext * ctx, struct MonoGenericContainer * gc, struct MonoGenericContext * context, struct MonoGenericInst * ginst)
{
  struct MonoGenericParamFull * D.23890;
  unsigned int i.42;
  unsigned int D.23892;
  int D.23893;
  int D.23896;
  gboolean D.23899;
  int D.23900;
  <unnamed-unsigned:22> D.23903;
  int D.23904;
  int i;

  i = 0;
  goto <D.20244>;
  <D.20243>:
  {
    struct MonoType * type;
    struct MonoGenericParam * target;
    struct MonoGenericParam * candidate;
    struct MonoClass * candidate_class;

    type = ginst->type_argv[i];
    D.23890 = gc->type_params;
    i.42 = (unsigned int) i;
    D.23892 = i.42 * 32;
    target = D.23890 + D.23892;
    D.23893 = mono_type_is_generic_argument (type);
    if (D.23893 == 0) goto <D.23894>; else goto <D.23895>;
    <D.23894>:
    // predicted unlikely by continue predictor.
    goto <D.20242>;
    <D.23895>:
    D.23896 = is_valid_type_in_context (ctx, type);
    if (D.23896 == 0) goto <D.23897>; else goto <D.23898>;
    <D.23897>:
    D.23899 = 0;
    return D.23899;
    <D.23898>:
    candidate = verifier_get_generic_param_from_type (ctx, type);
    candidate_class = mono_class_from_mono_type (type);
    D.23900 = mono_generic_param_is_constraint_compatible (ctx, target, candidate, candidate_class, context);
    if (D.23900 == 0) goto <D.23901>; else goto <D.23902>;
    <D.23901>:
    D.23899 = 0;
    return D.23899;
    <D.23902>:
  }
  <D.20242>:
  i = i + 1;
  <D.20244>:
  D.23903 = ginst->type_argc;
  D.23904 = (int) D.23903;
  if (D.23904 > i) goto <D.20243>; else goto <D.20245>;
  <D.20245>:
  D.23899 = 1;
  return D.23899;
}


verifier_get_generic_param_from_type (struct VerifyContext * ctx, struct MonoType * type)
{
  struct MonoGenericParam * D.23906;
  short unsigned int D.23907;
  unsigned char D.23908;
  struct MonoGenericClass * D.23911;
  unsigned char D.23915;
  unsigned char D.23916;
  struct MonoGenericParam * D.23921;
  struct MonoGenericParamFull * D.23922;
  unsigned int num.43;
  unsigned int D.23924;
  struct MonoGenericContainer * gc;
  struct MonoMethod * method;
  int num;

  method = ctx->method;
  D.23906 = type->data.generic_param;
  D.23907 = D.23906->num;
  num = (int) D.23907;
  D.23908 = type->type;
  if (D.23908 == 19) goto <D.23909>; else goto <D.23910>;
  <D.23909>:
  {
    struct MonoClass * gtd;

    gtd = method->klass;
    D.23911 = gtd->generic_class;
    if (D.23911 != 0B) goto <D.23912>; else goto <D.23913>;
    <D.23912>:
    D.23911 = gtd->generic_class;
    gtd = D.23911->container_class;
    <D.23913>:
    gc = gtd->generic_container;
  }
  goto <D.23914>;
  <D.23910>:
  {
    struct MonoMethod * gmd;

    gmd = method;
    D.23915 = BIT_FIELD_REF <*method, 8, 168>;
    D.23916 = D.23915 & 16;
    if (D.23916 != 0) goto <D.23917>; else goto <D.23918>;
    <D.23917>:
    gmd = MEM[(struct MonoMethodInflated *)method].declaring;
    <D.23918>:
    gc = mono_method_get_generic_container (gmd);
  }
  <D.23914>:
  if (gc == 0B) goto <D.23919>; else goto <D.23920>;
  <D.23919>:
  D.23921 = 0B;
  return D.23921;
  <D.23920>:
  D.23922 = gc->type_params;
  num.43 = (unsigned int) num;
  D.23924 = num.43 * 32;
  D.23921 = D.23922 + D.23924;
  return D.23921;
}


mono_generic_param_is_constraint_compatible (struct VerifyContext * ctx, struct MonoGenericParam * target, struct MonoGenericParam * candidate, struct MonoClass * candidate_param_class, struct MonoGenericContext * context)
{
  struct MonoGenericParamInfo * iftmp.44;
  struct MonoGenericContainer * D.23927;
  struct MonoGenericParamInfo * iftmp.45;
  struct MonoGenericContainer * D.23932;
  short unsigned int D.23936;
  int D.23937;
  short unsigned int D.23938;
  int D.23939;
  struct MonoClass * * D.23940;
  struct MonoClass * D.23943;
  struct MonoType * D.23944;
  struct MonoGenericContext * D.23945;
  gboolean D.23948;
  struct MonoType * D.23951;
  int D.23952;
  unsigned int D.23954;
  unsigned int D.23955;
  unsigned char D.23957;
  int D.23960;
  int D.23969;
  _Bool D.23970;
  int D.23971;
  int D.23972;
  _Bool D.23973;
  int D.23974;
  int D.23975;
  int D.23980;
  int D.23985;
  int D.23988;
  int D.23989;
  struct MonoClass * * D.23992;
  struct MonoClass * D.23995;
  struct MonoType * D.23996;
  struct MonoType * D.23999;
  struct MonoType * D.24000;
  int D.24001;
  int D.24008;
  struct MonoType * D.24010;
  int D.24011;
  int D.24014;
  struct MonoGenericParamInfo * tinfo;
  struct MonoGenericParamInfo * cinfo;
  struct MonoClass * * candidate_class;
  gboolean class_constraint_satisfied;
  gboolean valuetype_constraint_satisfied;
  int tmask;
  int cmask;

  D.23927 = target->owner;
  if (D.23927 != 0B) goto <D.23928>; else goto <D.23929>;
  <D.23928>:
  iftmp.44 = &MEM[(struct MonoGenericParamFull *)target].info;
  goto <D.23930>;
  <D.23929>:
  iftmp.44 = 0B;
  <D.23930>:
  tinfo = iftmp.44;
  D.23932 = candidate->owner;
  if (D.23932 != 0B) goto <D.23933>; else goto <D.23934>;
  <D.23933>:
  iftmp.45 = &MEM[(struct MonoGenericParamFull *)candidate].info;
  goto <D.23935>;
  <D.23934>:
  iftmp.45 = 0B;
  <D.23935>:
  cinfo = iftmp.45;
  class_constraint_satisfied = 0;
  valuetype_constraint_satisfied = 0;
  D.23936 = tinfo->flags;
  D.23937 = (int) D.23936;
  tmask = D.23937 & 28;
  D.23938 = cinfo->flags;
  D.23939 = (int) D.23938;
  cmask = D.23939 & 28;
  D.23940 = cinfo->constraints;
  if (D.23940 != 0B) goto <D.23941>; else goto <D.23942>;
  <D.23941>:
  candidate_class = cinfo->constraints;
  goto <D.20194>;
  <D.20193>:
  {
    struct MonoClass * cc;
    struct MonoType * inflated;

    D.23943 = *candidate_class;
    D.23944 = &D.23943->byval_arg;
    D.23945 = ctx->generic_context;
    inflated = verifier_inflate_type (ctx, D.23944, D.23945);
    if (inflated == 0B) goto <D.23946>; else goto <D.23947>;
    <D.23946>:
    D.23948 = 0;
    return D.23948;
    <D.23947>:
    cc = mono_class_from_mono_type (inflated);
    mono_metadata_free_type (inflated);
    D.23951 = &cc->byval_arg;
    D.23952 = mono_type_is_reference (D.23951);
    if (D.23952 != 0) goto <D.23953>; else goto <D.23949>;
    <D.23953>:
    D.23954 = cc->flags;
    D.23955 = D.23954 & 32;
    if (D.23955 == 0) goto <D.23956>; else goto <D.23949>;
    <D.23956>:
    D.23957 = cc->byval_arg.type;
    if (D.23957 != 19) goto <D.23958>; else goto <D.23949>;
    <D.23958>:
    D.23957 = cc->byval_arg.type;
    if (D.23957 != 30) goto <D.23959>; else goto <D.23949>;
    <D.23959>:
    class_constraint_satisfied = 1;
    goto <D.23950>;
    <D.23949>:
    D.23951 = &cc->byval_arg;
    D.23960 = mono_type_is_reference (D.23951);
    if (D.23960 == 0) goto <D.23961>; else goto <D.23962>;
    <D.23961>:
    D.23954 = cc->flags;
    D.23955 = D.23954 & 32;
    if (D.23955 == 0) goto <D.23963>; else goto <D.23964>;
    <D.23963>:
    D.23957 = cc->byval_arg.type;
    if (D.23957 != 19) goto <D.23965>; else goto <D.23966>;
    <D.23965>:
    D.23957 = cc->byval_arg.type;
    if (D.23957 != 30) goto <D.23967>; else goto <D.23968>;
    <D.23967>:
    valuetype_constraint_satisfied = 1;
    <D.23968>:
    <D.23966>:
    <D.23964>:
    <D.23962>:
    <D.23950>:
  }
  candidate_class = candidate_class + 4;
  <D.20194>:
  D.23943 = *candidate_class;
  if (D.23943 != 0B) goto <D.20193>; else goto <D.20195>;
  <D.20195>:
  <D.23942>:
  D.23969 = cmask & 4;
  D.23970 = D.23969 != 0;
  D.23971 = (int) D.23970;
  class_constraint_satisfied = D.23971 | class_constraint_satisfied;
  D.23972 = cmask & 8;
  D.23973 = D.23972 != 0;
  D.23974 = (int) D.23973;
  valuetype_constraint_satisfied = D.23974 | valuetype_constraint_satisfied;
  D.23975 = tmask & 4;
  if (D.23975 != 0) goto <D.23976>; else goto <D.23977>;
  <D.23976>:
  if (class_constraint_satisfied == 0) goto <D.23978>; else goto <D.23979>;
  <D.23978>:
  D.23948 = 0;
  return D.23948;
  <D.23979>:
  <D.23977>:
  D.23980 = tmask & 8;
  if (D.23980 != 0) goto <D.23981>; else goto <D.23982>;
  <D.23981>:
  if (valuetype_constraint_satisfied == 0) goto <D.23983>; else goto <D.23984>;
  <D.23983>:
  D.23948 = 0;
  return D.23948;
  <D.23984>:
  <D.23982>:
  D.23985 = tmask & 16;
  if (D.23985 != 0) goto <D.23986>; else goto <D.23987>;
  <D.23986>:
  D.23988 = cmask & 16;
  D.23989 = D.23988 | valuetype_constraint_satisfied;
  if (D.23989 == 0) goto <D.23990>; else goto <D.23991>;
  <D.23990>:
  D.23948 = 0;
  return D.23948;
  <D.23991>:
  <D.23987>:
  D.23992 = tinfo->constraints;
  if (D.23992 != 0B) goto <D.23993>; else goto <D.23994>;
  <D.23993>:
  {
    struct MonoClass * * target_class;

    target_class = tinfo->constraints;
    goto <D.20206>;
    <D.20205>:
    {
      struct MonoClass * tc;
      struct MonoType * inflated;

      D.23995 = *target_class;
      D.23996 = &D.23995->byval_arg;
      inflated = verifier_inflate_type (ctx, D.23996, context);
      if (inflated == 0B) goto <D.23997>; else goto <D.23998>;
      <D.23997>:
      D.23948 = 0;
      return D.23948;
      <D.23998>:
      tc = mono_class_from_mono_type (inflated);
      mono_metadata_free_type (inflated);
      D.23999 = &tc->byval_arg;
      D.24000 = &candidate_param_class->byval_arg;
      D.24001 = mono_metadata_type_equal (D.23999, D.24000);
      if (D.24001 != 0) goto <D.24002>; else goto <D.24003>;
      <D.24002>:
      // predicted unlikely by continue predictor.
      goto <D.20199>;
      <D.24003>:
      D.23940 = cinfo->constraints;
      if (D.23940 == 0B) goto <D.24004>; else goto <D.24005>;
      <D.24004>:
      D.23948 = 0;
      return D.23948;
      <D.24005>:
      candidate_class = cinfo->constraints;
      goto <D.20204>;
      <D.20203>:
      {
        struct MonoClass * cc;

        D.23943 = *candidate_class;
        D.23944 = &D.23943->byval_arg;
        D.23945 = ctx->generic_context;
        inflated = verifier_inflate_type (ctx, D.23944, D.23945);
        if (inflated == 0B) goto <D.24006>; else goto <D.24007>;
        <D.24006>:
        D.23948 = 0;
        return D.23948;
        <D.24007>:
        cc = mono_class_from_mono_type (inflated);
        mono_metadata_free_type (inflated);
        D.24008 = verifier_class_is_assignable_from (tc, cc);
        if (D.24008 != 0) goto <D.20201>; else goto <D.24009>;
        <D.24009>:
        D.24010 = &cc->byval_arg;
        D.24011 = mono_type_is_generic_argument (D.24010);
        if (D.24011 != 0) goto <D.24012>; else goto <D.24013>;
        <D.24012>:
        {
          struct MonoGenericParam * other_candidate;

          D.24010 = &cc->byval_arg;
          other_candidate = verifier_get_generic_param_from_type (ctx, D.24010);
          D.24014 = mono_generic_param_is_constraint_compatible (ctx, target, other_candidate, cc, context);
          if (D.24014 != 0) goto <D.20201>; else goto <D.24015>;
          <D.24015>:
        }
        <D.24013>:
      }
      candidate_class = candidate_class + 4;
      <D.20204>:
      D.23943 = *candidate_class;
      if (D.23943 != 0B) goto <D.20203>; else goto <D.20201>;
      <D.20201>:
      D.23943 = *candidate_class;
      if (D.23943 == 0B) goto <D.24016>; else goto <D.24017>;
      <D.24016>:
      D.23948 = 0;
      return D.23948;
      <D.24017>:
    }
    <D.20199>:
    target_class = target_class + 4;
    <D.20206>:
    D.23995 = *target_class;
    if (D.23995 != 0B) goto <D.20205>; else goto <D.20207>;
    <D.20207>:
  }
  <D.23994>:
  D.23948 = 1;
  return D.23948;
}


verifier_inflate_type (struct VerifyContext * ctx, struct MonoType * type, struct MonoGenericContext * context)
{
  int D.24019;
  struct MonoType * D.24022;
  struct MonoError error;
  struct MonoType * result;

  try
    {
      result = mono_class_inflate_generic_type_checked (type, context, &error);
      D.24019 = mono_error_ok (&error);
      if (D.24019 == 0) goto <D.24020>; else goto <D.24021>;
      <D.24020>:
      mono_error_cleanup (&error);
      D.24022 = 0B;
      return D.24022;
      <D.24021>:
      D.24022 = result;
      return D.24022;
    }
  finally
    {
      error = {CLOBBER};
    }
}


init_stack_with_value_at_exception_boundary (struct VerifyContext * ctx, struct ILCodeDesc * code, struct MonoClass * klass)
{
  struct MonoType * D.24025;
  struct MonoGenericContext * D.24026;
  int D.24027;
  gchar * D.24030;
  struct GSList * D.24031;
  struct GSList * D.24032;
  int D.24033;
  unsigned int D.24036;
  gchar * D.24037;
  struct GSList * D.24038;
  struct ILStackDesc * D.24039;
  struct GSList * D.24040;
  struct GSList * D.24041;
  short unsigned int D.24042;
  short unsigned int D.24043;
  int D.24044;
  int D.24047;
  int D.24048;
  struct MonoError error;
  struct MonoType * type;

  try
    {
      D.24025 = &klass->byval_arg;
      D.24026 = ctx->generic_context;
      type = mono_class_inflate_generic_type_checked (D.24025, D.24026, &error);
      D.24027 = mono_error_ok (&error);
      if (D.24027 == 0) goto <D.24028>; else goto <D.24029>;
      <D.24028>:
      {
        char * name;

        name = mono_type_get_full_name (klass);
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.24030 = monoeg_g_strdup_printf ("Invalid class %s used for exception", name);
          vinfo->info.message = D.24030;
          vinfo->exception_type = 3;
          D.24031 = ctx->list;
          D.24032 = monoeg_g_slist_prepend (D.24031, vinfo);
          ctx->list = D.24032;
        }
        ctx->valid = 0;
        monoeg_g_free (name);
        mono_error_cleanup (&error);
        return;
      }
      <D.24029>:
      D.24033 = ctx->max_stack;
      if (D.24033 == 0) goto <D.24034>; else goto <D.24035>;
      <D.24034>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24036 = ctx->ip_offset;
        D.24037 = monoeg_g_strdup_printf ("Stack overflow at 0x%04x", D.24036);
        vinfo->info.message = D.24037;
        vinfo->exception_type = 3;
        D.24031 = ctx->list;
        D.24038 = monoeg_g_slist_prepend (D.24031, vinfo);
        ctx->list = D.24038;
      }
      ctx->valid = 0;
      return;
      <D.24035>:
      stack_init (ctx, code);
      ensure_stack_size (code, 1);
      D.24039 = code->stack;
      set_stack_value (ctx, D.24039, type, 0);
      D.24040 = ctx->exception_types;
      D.24041 = monoeg_g_slist_prepend (D.24040, type);
      ctx->exception_types = D.24041;
      code->size = 1;
      D.24042 = code->flags;
      D.24043 = D.24042 | 2;
      code->flags = D.24043;
      D.24044 = mono_type_is_generic_argument (type);
      if (D.24044 != 0) goto <D.24045>; else goto <D.24046>;
      <D.24045>:
      D.24039 = code->stack;
      D.24039 = code->stack;
      D.24047 = D.24039->stype;
      D.24048 = D.24047 | 4096;
      D.24039->stype = D.24048;
      <D.24046>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


ensure_stack_size (struct ILCodeDesc * stack, int required)
{
  short unsigned int D.24052;
  int D.24053;
  int D.24056;
  int D.24057;
  short unsigned int D.24058;
  int D.24059;
  _Bool D.24060;
  long int D.24061;
  long int D.24062;
  _Bool D.24065;
  long int D.24066;
  long int D.24067;
  unsigned int new_size.46;
  unsigned int D.24071;
  struct ILStackDesc * D.24072;
  unsigned int D.24077;
  unsigned int D.24078;
  short unsigned int D.24079;
  int new_size;
  struct ILStackDesc * tmp;

  new_size = 8;
  D.24052 = stack->max_size;
  D.24053 = (int) D.24052;
  if (D.24053 > required) goto <D.24054>; else goto <D.24055>;
  <D.24054>:
  return;
  <D.24055>:
  D.24052 = stack->max_size;
  D.24053 = (int) D.24052;
  D.24056 = D.24053 * 2;
  D.24057 = MAX_EXPR <D.24056, required>;
  new_size = MAX_EXPR <D.24057, 8>;
  D.24058 = stack->size;
  D.24059 = (int) D.24058;
  D.24060 = D.24059 > new_size;
  D.24061 = (long int) D.24060;
  D.24062 = __builtin_expect (D.24061, 0);
  if (D.24062 != 0) goto <D.24063>; else goto <D.24064>;
  <D.24063>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "verify.c", 1499, "new_size >= stack->size");
  <D.24064>:
  D.24065 = new_size < required;
  D.24066 = (long int) D.24065;
  D.24067 = __builtin_expect (D.24066, 0);
  if (D.24067 != 0) goto <D.24068>; else goto <D.24069>;
  <D.24068>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "verify.c", 1500, "new_size >= required");
  <D.24069>:
  new_size.46 = (unsigned int) new_size;
  D.24071 = new_size.46 * 12;
  tmp = monoeg_malloc0 (D.24071);
  D.24072 = stack->stack;
  if (D.24072 != 0B) goto <D.24073>; else goto <D.24074>;
  <D.24073>:
  D.24058 = stack->size;
  if (D.24058 != 0) goto <D.24075>; else goto <D.24076>;
  <D.24075>:
  D.24072 = stack->stack;
  D.24058 = stack->size;
  D.24077 = (unsigned int) D.24058;
  D.24078 = D.24077 * 12;
  memcpy (tmp, D.24072, D.24078);
  <D.24076>:
  D.24072 = stack->stack;
  monoeg_g_free (D.24072);
  <D.24074>:
  stack->stack = tmp;
  D.24079 = (short unsigned int) new_size;
  stack->max_size = D.24079;
}


mono_opcode_is_prefix (int op)
{
  gboolean D.24081;

  switch (op) <default: <D.24082>, case 274: <D.21587>, case 275: <D.21588>, case 276: <D.21589>, case 278: <D.21590>, case 286: <D.21591>>
  <D.21587>:
  <D.21588>:
  <D.21589>:
  <D.21590>:
  <D.21591>:
  D.24081 = 1;
  return D.24081;
  <D.24082>:
  D.24081 = 0;
  return D.24081;
}


merge_stacks (struct VerifyContext * ctx, struct ILCodeDesc * from, struct ILCodeDesc * to, gboolean start, gboolean external)
{
  short unsigned int D.24086;
  struct ILCodeDesc * D.24090;
  int D.24091;
  int D.24092;
  short unsigned int D.24095;
  short unsigned int D.24096;
  int D.24099;
  int D.24100;
  unsigned int D.24101;
  gchar * D.24102;
  struct GSList * D.24103;
  struct GSList * D.24104;
  struct ILStackDesc * D.24105;
  unsigned int i.47;
  unsigned int D.24107;
  struct ILStackDesc * D.24108;
  int D.24109;
  int D.24112;
  int D.24115;
  int D.24118;
  int D.24121;
  int D.24126;
  int D.24128;
  int D.24131;
  int D.24133;
  int D.24134;
  gchar * D.24135;
  struct GSList * D.24136;
  int D.24137;
  struct MonoClass * D.24141;
  unsigned char D.24142;
  unsigned char D.24143;
  struct MonoClass * D.24145;
  unsigned char D.24146;
  unsigned char D.24147;
  int D.24149;
  int D.24151;
  short unsigned int D.24153;
  short unsigned int D.24154;
  short unsigned int D.24155;
  int D.24156;
  struct MonoClass * * D.24157;
  unsigned int j.48;
  unsigned int D.24159;
  struct MonoClass * * D.24160;
  struct MonoClass * D.24161;
  struct MonoType * D.24162;
  struct MonoClass * * D.24163;
  struct MonoClass * * D.24164;
  struct MonoClass * D.24165;
  struct MonoType * D.24166;
  int D.24167;
  int D.24170;
  const char * D.24176;
  gchar * D.24177;
  struct GSList * D.24178;
  int D.24181;
  const char * D.24187;
  gchar * D.24188;
  struct GSList * D.24189;
  unsigned int D.24192;
  unsigned int D.24193;
  int D.24196;
  struct MonoClass * * D.24199;
  struct MonoClass * * D.24200;
  struct MonoClass * D.24201;
  int D.24202;
  short unsigned int D.24205;
  int D.24206;
  unsigned int D.24207;
  unsigned int D.24208;
  int D.24211;
  struct MonoClass * * D.24214;
  struct MonoClass * * D.24215;
  struct MonoClass * D.24216;
  int D.24217;
  short unsigned int D.24220;
  int D.24221;
  int D.24224;
  int D.24226;
  gchar * D.24230;
  struct GSList * D.24231;
  struct MonoType * D.24234;
  int D.24235;
  _Bool D.24236;
  long int D.24237;
  long int D.24238;
  struct MonoType * D.24241;
  int D.24242;
  int D.24243;
  short unsigned int D.24246;
  short unsigned int D.24247;
  struct MonoError error;
  int i;
  int j;
  void end_verify = <<< error >>>;
  void match_found = <<< error >>>;

  try
    {
      stack_init (ctx, to);
      if (start != 0) goto <D.24084>; else goto <D.24085>;
      <D.24084>:
      D.24086 = to->flags;
      if (D.24086 == 0) goto <D.24087>; else goto <D.24088>;
      <D.24087>:
      from->size = 0;
      goto <D.24089>;
      <D.24088>:
      D.24090 = &ctx->eval;
      stack_copy (D.24090, to);
      <D.24089>:
      goto end_verify;
      <D.24085>:
      D.24086 = to->flags;
      D.24091 = (int) D.24086;
      D.24092 = D.24091 & 8;
      if (D.24092 == 0) goto <D.24093>; else goto <D.24094>;
      <D.24093>:
      D.24090 = &ctx->eval;
      stack_copy (to, D.24090);
      goto end_verify;
      <D.24094>:
      D.24095 = from->size;
      D.24096 = to->size;
      if (D.24095 != D.24096) goto <D.24097>; else goto <D.24098>;
      <D.24097>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24095 = from->size;
        D.24099 = (int) D.24095;
        D.24096 = to->size;
        D.24100 = (int) D.24096;
        D.24101 = ctx->ip_offset;
        D.24102 = monoeg_g_strdup_printf ("Could not merge stacks, different sizes (%d x %d) at 0x%04x", D.24099, D.24100, D.24101);
        vinfo->info.message = D.24102;
        vinfo->exception_type = 3;
        D.24103 = ctx->list;
        D.24104 = monoeg_g_slist_prepend (D.24103, vinfo);
        ctx->list = D.24104;
      }
      ctx->valid = 0;
      goto end_verify;
      <D.24098>:
      i = 0;
      goto <D.21558>;
      <D.21557>:
      {
        struct ILStackDesc * new_slot;
        struct ILStackDesc * old_slot;
        struct MonoType * new_type;
        struct MonoType * old_type;
        struct MonoClass * old_class;
        struct MonoClass * new_class;
        struct MonoClass * match_class;

        D.24105 = from->stack;
        i.47 = (unsigned int) i;
        D.24107 = i.47 * 12;
        new_slot = D.24105 + D.24107;
        D.24108 = to->stack;
        i.47 = (unsigned int) i;
        D.24107 = i.47 * 12;
        old_slot = D.24108 + D.24107;
        new_type = mono_type_from_stack_slot (new_slot);
        old_type = mono_type_from_stack_slot (old_slot);
        old_class = mono_class_from_mono_type (old_type);
        new_class = mono_class_from_mono_type (new_type);
        match_class = 0B;
        D.24109 = verify_stack_type_compatibility (ctx, old_type, new_slot);
        if (D.24109 != 0) goto <D.24110>; else goto <D.24111>;
        <D.24110>:
        copy_stack_value (new_slot, old_slot);
        // predicted unlikely by continue predictor.
        goto <D.21538>;
        <D.24111>:
        D.24112 = verify_stack_type_compatibility (ctx, new_type, old_slot);
        if (D.24112 != 0) goto <D.24113>; else goto <D.24114>;
        <D.24113>:
        copy_stack_value (old_slot, new_slot);
        // predicted unlikely by continue predictor.
        goto <D.21538>;
        <D.24114>:
        D.24115 = stack_slot_is_boxed_value (old_slot);
        if (D.24115 != 0) goto <D.24116>; else goto <D.24117>;
        <D.24116>:
        D.24118 = stack_slot_is_boxed_value (new_slot);
        if (D.24118 != 0) goto <D.24119>; else goto <D.24120>;
        <D.24119>:
        D.24121 = mono_metadata_type_equal (old_type, new_type);
        if (D.24121 != 0) goto <D.24122>; else goto <D.24123>;
        <D.24122>:
        copy_stack_value (new_slot, old_slot);
        // predicted unlikely by continue predictor.
        goto <D.21538>;
        <D.24123>:
        <D.24120>:
        <D.24117>:
        D.24126 = mono_type_is_generic_argument (old_type);
        if (D.24126 != 0) goto <D.24124>; else goto <D.24127>;
        <D.24127>:
        D.24128 = mono_type_is_generic_argument (new_type);
        if (D.24128 != 0) goto <D.24124>; else goto <D.24125>;
        <D.24124>:
        {
          char * old_name;
          char * new_name;

          old_name = stack_slot_full_name (old_slot);
          new_name = stack_slot_full_name (new_slot);
          D.24131 = ctx->verifiable;
          if (D.24131 != 0) goto <D.24129>; else goto <D.24132>;
          <D.24132>:
          D.24133 = ctx->level;
          D.24134 = D.24133 & 128;
          if (D.24134 != 0) goto <D.24129>; else goto <D.24130>;
          <D.24129>:
          {
            struct MonoVerifyInfoExtended * vinfo;

            vinfo = monoeg_malloc (12);
            vinfo->info.status = 8;
            D.24101 = ctx->ip_offset;
            D.24135 = monoeg_g_strdup_printf ("Could not merge stack at depth %d, types not compatible: %s X %s at 0x%04x", i, old_name, new_name, D.24101);
            vinfo->info.message = D.24135;
            vinfo->exception_type = 4;
            D.24103 = ctx->list;
            D.24136 = monoeg_g_slist_prepend (D.24103, vinfo);
            ctx->list = D.24136;
          }
          ctx->verifiable = 0;
          D.24133 = ctx->level;
          D.24137 = D.24133 & 16;
          if (D.24137 != 0) goto <D.24138>; else goto <D.24139>;
          <D.24138>:
          ctx->valid = 0;
          <D.24139>:
          <D.24130>:
          monoeg_g_free (old_name);
          monoeg_g_free (new_name);
          goto end_verify;
        }
        <D.24125>:
        D.24141 = mono_class_from_mono_type (old_type);
        D.24142 = BIT_FIELD_REF <*D.24141, 8, 160>;
        D.24143 = D.24142 & 8;
        if (D.24143 == 0) goto <D.24144>; else goto <D.24140>;
        <D.24144>:
        D.24145 = mono_class_from_mono_type (new_type);
        D.24146 = BIT_FIELD_REF <*D.24145, 8, 160>;
        D.24147 = D.24146 & 8;
        if (D.24147 == 0) goto <D.24148>; else goto <D.24140>;
        <D.24148>:
        D.24149 = stack_slot_is_managed_pointer (old_slot);
        if (D.24149 == 0) goto <D.24150>; else goto <D.24140>;
        <D.24150>:
        D.24151 = stack_slot_is_managed_pointer (new_slot);
        if (D.24151 == 0) goto <D.24152>; else goto <D.24140>;
        <D.24152>:
        mono_class_setup_supertypes (old_class);
        mono_class_setup_supertypes (new_class);
        D.24153 = new_class->idepth;
        D.24154 = old_class->idepth;
        D.24155 = MIN_EXPR <D.24153, D.24154>;
        D.24156 = (int) D.24155;
        j = D.24156 + -1;
        goto <D.21544>;
        <D.21543>:
        D.24157 = old_class->supertypes;
        j.48 = (unsigned int) j;
        D.24159 = j.48 * 4;
        D.24160 = D.24157 + D.24159;
        D.24161 = *D.24160;
        D.24162 = &D.24161->byval_arg;
        D.24163 = new_class->supertypes;
        j.48 = (unsigned int) j;
        D.24159 = j.48 * 4;
        D.24164 = D.24163 + D.24159;
        D.24165 = *D.24164;
        D.24166 = &D.24165->byval_arg;
        D.24167 = mono_metadata_type_equal (D.24162, D.24166);
        if (D.24167 != 0) goto <D.24168>; else goto <D.24169>;
        <D.24168>:
        D.24157 = old_class->supertypes;
        j.48 = (unsigned int) j;
        D.24159 = j.48 * 4;
        D.24160 = D.24157 + D.24159;
        match_class = *D.24160;
        goto match_found;
        <D.24169>:
        j = j + -1;
        <D.21544>:
        if (j > 0) goto <D.21543>; else goto <D.21545>;
        <D.21545>:
        mono_class_setup_interfaces (old_class, &error);
        D.24170 = mono_error_ok (&error);
        if (D.24170 == 0) goto <D.24171>; else goto <D.24172>;
        <D.24171>:
        D.24131 = ctx->verifiable;
        if (D.24131 != 0) goto <D.24173>; else goto <D.24175>;
        <D.24175>:
        D.24133 = ctx->level;
        D.24134 = D.24133 & 128;
        if (D.24134 != 0) goto <D.24173>; else goto <D.24174>;
        <D.24173>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.24176 = mono_error_get_message (&error);
          D.24101 = ctx->ip_offset;
          D.24177 = monoeg_g_strdup_printf ("Cannot merge stacks due to a TypeLoadException %s at 0x%04x", D.24176, D.24101);
          vinfo->info.message = D.24177;
          vinfo->exception_type = 4;
          D.24103 = ctx->list;
          D.24178 = monoeg_g_slist_prepend (D.24103, vinfo);
          ctx->list = D.24178;
        }
        ctx->verifiable = 0;
        D.24133 = ctx->level;
        D.24137 = D.24133 & 16;
        if (D.24137 != 0) goto <D.24179>; else goto <D.24180>;
        <D.24179>:
        ctx->valid = 0;
        <D.24180>:
        <D.24174>:
        mono_error_cleanup (&error);
        goto end_verify;
        <D.24172>:
        mono_class_setup_interfaces (new_class, &error);
        D.24181 = mono_error_ok (&error);
        if (D.24181 == 0) goto <D.24182>; else goto <D.24183>;
        <D.24182>:
        D.24131 = ctx->verifiable;
        if (D.24131 != 0) goto <D.24184>; else goto <D.24186>;
        <D.24186>:
        D.24133 = ctx->level;
        D.24134 = D.24133 & 128;
        if (D.24134 != 0) goto <D.24184>; else goto <D.24185>;
        <D.24184>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.24187 = mono_error_get_message (&error);
          D.24101 = ctx->ip_offset;
          D.24188 = monoeg_g_strdup_printf ("Cannot merge stacks due to a TypeLoadException %s at 0x%04x", D.24187, D.24101);
          vinfo->info.message = D.24188;
          vinfo->exception_type = 4;
          D.24103 = ctx->list;
          D.24189 = monoeg_g_slist_prepend (D.24103, vinfo);
          ctx->list = D.24189;
        }
        ctx->verifiable = 0;
        D.24133 = ctx->level;
        D.24137 = D.24133 & 16;
        if (D.24137 != 0) goto <D.24190>; else goto <D.24191>;
        <D.24190>:
        ctx->valid = 0;
        <D.24191>:
        <D.24185>:
        mono_error_cleanup (&error);
        goto end_verify;
        <D.24183>:
        D.24192 = old_class->flags;
        D.24193 = D.24192 & 32;
        if (D.24193 != 0) goto <D.24194>; else goto <D.24195>;
        <D.24194>:
        D.24196 = verifier_class_is_assignable_from (old_class, new_class);
        if (D.24196 != 0) goto <D.24197>; else goto <D.24198>;
        <D.24197>:
        match_class = old_class;
        goto match_found;
        <D.24198>:
        j = 0;
        goto <D.21549>;
        <D.21548>:
        D.24199 = old_class->interfaces;
        j.48 = (unsigned int) j;
        D.24159 = j.48 * 4;
        D.24200 = D.24199 + D.24159;
        D.24201 = *D.24200;
        D.24202 = verifier_class_is_assignable_from (D.24201, new_class);
        if (D.24202 != 0) goto <D.24203>; else goto <D.24204>;
        <D.24203>:
        D.24199 = old_class->interfaces;
        j.48 = (unsigned int) j;
        D.24159 = j.48 * 4;
        D.24200 = D.24199 + D.24159;
        match_class = *D.24200;
        goto match_found;
        <D.24204>:
        j = j + 1;
        <D.21549>:
        D.24205 = old_class->interface_count;
        D.24206 = (int) D.24205;
        if (D.24206 > j) goto <D.21548>; else goto <D.21550>;
        <D.21550>:
        <D.24195>:
        D.24207 = new_class->flags;
        D.24208 = D.24207 & 32;
        if (D.24208 != 0) goto <D.24209>; else goto <D.24210>;
        <D.24209>:
        D.24211 = verifier_class_is_assignable_from (new_class, old_class);
        if (D.24211 != 0) goto <D.24212>; else goto <D.24213>;
        <D.24212>:
        match_class = new_class;
        goto match_found;
        <D.24213>:
        j = 0;
        goto <D.21552>;
        <D.21551>:
        D.24214 = new_class->interfaces;
        j.48 = (unsigned int) j;
        D.24159 = j.48 * 4;
        D.24215 = D.24214 + D.24159;
        D.24216 = *D.24215;
        D.24217 = verifier_class_is_assignable_from (D.24216, old_class);
        if (D.24217 != 0) goto <D.24218>; else goto <D.24219>;
        <D.24218>:
        D.24214 = new_class->interfaces;
        j.48 = (unsigned int) j;
        D.24159 = j.48 * 4;
        D.24215 = D.24214 + D.24159;
        match_class = *D.24215;
        goto match_found;
        <D.24219>:
        j = j + 1;
        <D.21552>:
        D.24220 = new_class->interface_count;
        D.24221 = (int) D.24220;
        if (D.24221 > j) goto <D.21551>; else goto <D.21553>;
        <D.21553>:
        <D.24210>:
        match_class = mono_defaults.object_class;
        goto match_found;
        <D.24140>:
        D.24224 = is_compatible_boxed_valuetype (ctx, old_type, new_type, new_slot, 0);
        if (D.24224 != 0) goto <D.24222>; else goto <D.24225>;
        <D.24225>:
        D.24226 = is_compatible_boxed_valuetype (ctx, new_type, old_type, old_slot, 0);
        if (D.24226 != 0) goto <D.24222>; else goto <D.24223>;
        <D.24222>:
        match_class = mono_defaults.object_class;
        goto match_found;
        <D.24223>:
        {
          char * old_name;
          char * new_name;

          old_name = stack_slot_full_name (old_slot);
          new_name = stack_slot_full_name (new_slot);
          D.24131 = ctx->verifiable;
          if (D.24131 != 0) goto <D.24227>; else goto <D.24229>;
          <D.24229>:
          D.24133 = ctx->level;
          D.24134 = D.24133 & 128;
          if (D.24134 != 0) goto <D.24227>; else goto <D.24228>;
          <D.24227>:
          {
            struct MonoVerifyInfoExtended * vinfo;

            vinfo = monoeg_malloc (12);
            vinfo->info.status = 8;
            D.24101 = ctx->ip_offset;
            D.24230 = monoeg_g_strdup_printf ("Could not merge stack at depth %d, types not compatible: %s X %s at 0x%04x", i, old_name, new_name, D.24101);
            vinfo->info.message = D.24230;
            vinfo->exception_type = 4;
            D.24103 = ctx->list;
            D.24231 = monoeg_g_slist_prepend (D.24103, vinfo);
            ctx->list = D.24231;
          }
          ctx->verifiable = 0;
          D.24133 = ctx->level;
          D.24137 = D.24133 & 16;
          if (D.24137 != 0) goto <D.24232>; else goto <D.24233>;
          <D.24232>:
          ctx->valid = 0;
          <D.24233>:
          <D.24228>:
          monoeg_g_free (old_name);
          monoeg_g_free (new_name);
        }
        D.24234 = &new_class->byval_arg;
        D.24235 = stack_slot_is_managed_pointer (old_slot);
        set_stack_value (ctx, old_slot, D.24234, D.24235);
        goto end_verify;
        match_found:
        D.24236 = match_class == 0B;
        D.24237 = (long int) D.24236;
        D.24238 = __builtin_expect (D.24237, 0);
        if (D.24238 != 0) goto <D.24239>; else goto <D.24240>;
        <D.24239>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "verify.c", 4668, "match_class");
        <D.24240>:
        D.24241 = &match_class->byval_arg;
        D.24242 = stack_slot_is_managed_pointer (old_slot);
        set_stack_value (ctx, old_slot, D.24241, D.24242);
        D.24241 = &match_class->byval_arg;
        D.24243 = stack_slot_is_managed_pointer (old_slot);
        set_stack_value (ctx, new_slot, D.24241, D.24243);
        // predicted unlikely by continue predictor.
        goto <D.21538>;
      }
      <D.21538>:
      i = i + 1;
      <D.21558>:
      D.24095 = from->size;
      D.24099 = (int) D.24095;
      if (D.24099 > i) goto <D.21557>; else goto <D.21559>;
      <D.21559>:
      end_verify:
      if (external != 0) goto <D.24244>; else goto <D.24245>;
      <D.24244>:
      D.24086 = to->flags;
      D.24246 = D.24086 | 2;
      to->flags = D.24246;
      <D.24245>:
      D.24086 = to->flags;
      D.24247 = D.24086 | 8;
      to->flags = D.24247;
    }
  finally
    {
      error = {CLOBBER};
    }
}


stack_copy (struct ILCodeDesc * to, struct ILCodeDesc * from)
{
  short unsigned int D.24248;
  int D.24249;
  struct ILStackDesc * D.24252;
  struct ILStackDesc * D.24253;
  unsigned int D.24254;
  unsigned int D.24255;

  D.24248 = from->size;
  D.24249 = (int) D.24248;
  ensure_stack_size (to, D.24249);
  D.24248 = from->size;
  to->size = D.24248;
  D.24248 = from->size;
  if (D.24248 != 0) goto <D.24250>; else goto <D.24251>;
  <D.24250>:
  D.24252 = to->stack;
  D.24253 = from->stack;
  D.24248 = from->size;
  D.24254 = (unsigned int) D.24248;
  D.24255 = D.24254 * 12;
  memcpy (D.24252, D.24253, D.24255);
  <D.24251>:
}


mono_type_from_stack_slot (struct ILStackDesc * slot)
{
  int D.24256;
  struct MonoType * D.24259;
  struct MonoType * D.24260;

  D.24256 = stack_slot_is_managed_pointer (slot);
  if (D.24256 != 0) goto <D.24257>; else goto <D.24258>;
  <D.24257>:
  D.24260 = slot->type;
  D.24259 = mono_type_get_type_byref (D.24260);
  return D.24259;
  <D.24258>:
  D.24259 = slot->type;
  return D.24259;
}


mono_type_get_type_byref (struct MonoType * type)
{
  unsigned char D.24262;
  unsigned char D.24263;
  struct MonoType * D.24266;
  struct MonoClass * D.24267;

  D.24262 = BIT_FIELD_REF <*type, 8, 56>;
  D.24263 = D.24262 & 64;
  if (D.24263 != 0) goto <D.24264>; else goto <D.24265>;
  <D.24264>:
  D.24266 = type;
  return D.24266;
  <D.24265>:
  D.24267 = mono_class_from_mono_type (type);
  D.24266 = &D.24267->this_arg;
  return D.24266;
}


verify_stack_type_compatibility (struct VerifyContext * ctx, struct MonoType * type, struct ILStackDesc * stack)
{
  int D.24269;

  D.24269 = verify_stack_type_compatibility_full (ctx, type, stack, 0, 0);
  return D.24269;
}


verify_stack_type_compatibility_full (struct VerifyContext * ctx, struct MonoType * type, struct ILStackDesc * stack, gboolean drop_byref, gboolean valuetype_must_be_boxed)
{
  int D.24271;
  unsigned char D.24274;
  unsigned char D.24275;
  int D.24278;
  int D.24281;
  int D.24282;
  int D.24287;
  int D.24290;
  int D.24295;
  struct MonoType * D.24300;
  struct MonoType * candidate;

  candidate = mono_type_from_stack_slot (stack);
  D.24271 = mono_type_is_reference (type);
  if (D.24271 != 0) goto <D.24272>; else goto <D.24273>;
  <D.24272>:
  D.24274 = BIT_FIELD_REF <*type, 8, 56>;
  D.24275 = D.24274 & 64;
  if (D.24275 == 0) goto <D.24276>; else goto <D.24277>;
  <D.24276>:
  D.24278 = stack_slot_is_null_literal (stack);
  if (D.24278 != 0) goto <D.24279>; else goto <D.24280>;
  <D.24279>:
  D.24281 = 1;
  return D.24281;
  <D.24280>:
  <D.24277>:
  <D.24273>:
  D.24282 = is_compatible_boxed_valuetype (ctx, type, candidate, stack, 1);
  if (D.24282 != 0) goto <D.24283>; else goto <D.24284>;
  <D.24283>:
  D.24281 = 1;
  return D.24281;
  <D.24284>:
  if (valuetype_must_be_boxed != 0) goto <D.24285>; else goto <D.24286>;
  <D.24285>:
  D.24287 = stack_slot_is_boxed_value (stack);
  if (D.24287 == 0) goto <D.24288>; else goto <D.24289>;
  <D.24288>:
  D.24290 = mono_type_is_reference (candidate);
  if (D.24290 == 0) goto <D.24291>; else goto <D.24292>;
  <D.24291>:
  D.24281 = 0;
  return D.24281;
  <D.24292>:
  <D.24289>:
  <D.24286>:
  if (valuetype_must_be_boxed == 0) goto <D.24293>; else goto <D.24294>;
  <D.24293>:
  D.24295 = stack_slot_is_boxed_value (stack);
  if (D.24295 != 0) goto <D.24296>; else goto <D.24297>;
  <D.24296>:
  D.24281 = 0;
  return D.24281;
  <D.24297>:
  <D.24294>:
  if (drop_byref != 0) goto <D.24298>; else goto <D.24299>;
  <D.24298>:
  D.24300 = mono_type_get_type_byval (candidate);
  D.24281 = verify_type_compatibility_full (ctx, type, D.24300, 0);
  return D.24281;
  <D.24299>:
  D.24281 = verify_type_compatibility_full (ctx, type, candidate, 0);
  return D.24281;
}


stack_slot_is_null_literal (struct ILStackDesc * value)
{
  gboolean D.24302;
  int D.24303;
  int D.24304;
  _Bool D.24305;

  D.24303 = value->stype;
  D.24304 = D.24303 & 1024;
  D.24305 = D.24304 != 0;
  D.24302 = (gboolean) D.24305;
  return D.24302;
}


mono_type_get_type_byval (struct MonoType * type)
{
  unsigned char D.24307;
  unsigned char D.24308;
  struct MonoType * D.24311;
  struct MonoClass * D.24312;

  D.24307 = BIT_FIELD_REF <*type, 8, 56>;
  D.24308 = D.24307 & 64;
  if (D.24308 == 0) goto <D.24309>; else goto <D.24310>;
  <D.24309>:
  D.24311 = type;
  return D.24311;
  <D.24310>:
  D.24312 = mono_class_from_mono_type (type);
  D.24311 = &D.24312->byval_arg;
  return D.24311;
}


verify_type_compatibility_full (struct VerifyContext * ctx, struct MonoType * target, struct MonoType * candidate, gboolean strict)
{
  unsigned char D.24314;
  unsigned char D.24315;
  unsigned char D.24316;
  unsigned char D.24317;
  int D.24320;
  unsigned char D.24323;
  int D.24328;
  int D.24330;
  int D.24331;
  unsigned int D.24332;
  gchar * D.24333;
  struct GSList * D.24334;
  struct GSList * D.24335;
  int D.24336;
  gboolean D.24339;
  <unnamed-unsigned:1> D.24340;
  int D.24341;
  unsigned char D.24342;
  int D.24343;
  unsigned char D.24344;
  _Bool D.24345;
  unsigned char D.24348;
  unsigned char D.24349;
  _Bool D.24350;
  _Bool D.24351;
  _Bool D.24352;
  unsigned char D.24355;
  unsigned char D.24356;
  _Bool D.24357;
  _Bool D.24358;
  _Bool D.24359;
  unsigned char D.24360;
  _Bool D.24361;
  unsigned char D.24362;
  _Bool D.24363;
  int D.24366;
  _Bool D.24367;
  int iftmp.49;
  int D.24373;
  unsigned char D.24374;
  _Bool D.24375;
  _Bool D.24378;
  unsigned char D.24379;
  _Bool D.24380;
  int D.24383;
  _Bool D.24384;
  int iftmp.50;
  int D.24390;
  struct MonoType * D.24393;
  struct MonoType * D.24394;
  int iftmp.51;
  int D.24400;
  unsigned char D.24402;
  unsigned char D.24403;
  unsigned char D.24404;
  unsigned char D.24405;
  int D.24407;
  int D.24412;
  int D.24415;
  int D.24418;
  _Bool D.24421;
  _Bool D.24422;
  int D.24423;
  struct MonoClass * D.24428;
  struct MonoClass * D.24429;
  _Bool D.24434;
  int D.24439;
  struct MonoGenericParam * D.24446;
  short unsigned int D.24447;
  struct MonoGenericParam * D.24448;
  short unsigned int D.24449;
  _Bool D.24450;
  struct MonoType * original_candidate;
  void handle_enum = <<< error >>>;

  original_candidate = candidate;
  D.24314 = BIT_FIELD_REF <*candidate, 8, 56>;
  D.24315 = BIT_FIELD_REF <*target, 8, 56>;
  D.24316 = D.24314 ^ D.24315;
  D.24317 = D.24316 & 64;
  if (D.24317 != 0) goto <D.24318>; else goto <D.24319>;
  <D.24318>:
  D.24320 = get_stack_type (candidate);
  if (D.24320 == 3) goto <D.24321>; else goto <D.24322>;
  <D.24321>:
  D.24315 = BIT_FIELD_REF <*target, 8, 56>;
  D.24323 = D.24315 & 64;
  if (D.24323 != 0) goto <D.24324>; else goto <D.24325>;
  <D.24324>:
  D.24328 = ctx->verifiable;
  if (D.24328 != 0) goto <D.24326>; else goto <D.24329>;
  <D.24329>:
  D.24330 = ctx->level;
  D.24331 = D.24330 & 128;
  if (D.24331 != 0) goto <D.24326>; else goto <D.24327>;
  <D.24326>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.24332 = ctx->ip_offset;
    D.24333 = monoeg_g_strdup_printf ("using byref native int at 0x%04x", D.24332);
    vinfo->info.message = D.24333;
    vinfo->exception_type = 4;
    D.24334 = ctx->list;
    D.24335 = monoeg_g_slist_prepend (D.24334, vinfo);
    ctx->list = D.24335;
  }
  ctx->verifiable = 0;
  D.24330 = ctx->level;
  D.24336 = D.24330 & 16;
  if (D.24336 != 0) goto <D.24337>; else goto <D.24338>;
  <D.24337>:
  ctx->valid = 0;
  <D.24338>:
  <D.24327>:
  D.24339 = 1;
  return D.24339;
  <D.24325>:
  <D.24322>:
  D.24339 = 0;
  return D.24339;
  <D.24319>:
  D.24340 = target->byref;
  D.24341 = (int) D.24340;
  strict = D.24341 | strict;
  candidate = mono_type_get_underlying_type_any (candidate);
  handle_enum:
  D.24342 = target->type;
  D.24343 = (int) D.24342;
  switch (D.24343) <default: <D.20745>, case 1: <D.20706>, case 2: <D.20709>, case 3: <D.20712>, case 4: <D.20707>, case 5: <D.20708>, case 6: <D.20710>, case 7: <D.20711>, case 8: <D.20713>, case 9: <D.20714>, case 10: <D.20717>, case 11: <D.20718>, case 12: <D.20719>, case 13: <D.20720>, case 14: <D.20732>, case 15: <D.20725>, case 17: <D.20740>, case 18: <D.20733>, case 19: <D.20743>, case 20: <D.20738>, case 21: <D.20729>, case 22: <D.20739>, case 24: <D.20721>, case 25: <D.20722>, case 27: <D.20726>, case 28: <D.20734>, case 29: <D.20735>, case 30: <D.20744>>
  <D.20706>:
  D.24344 = candidate->type;
  D.24345 = D.24344 == 1;
  D.24339 = (gboolean) D.24345;
  return D.24339;
  <D.20707>:
  <D.20708>:
  <D.20709>:
  if (strict != 0) goto <D.24346>; else goto <D.24347>;
  <D.24346>:
  D.24348 = candidate->type;
  D.24349 = D.24348 + 252;
  D.24350 = D.24349 <= 1;
  D.24351 = D.24348 == 2;
  D.24352 = D.24350 | D.24351;
  D.24339 = (gboolean) D.24352;
  return D.24339;
  <D.24347>:
  <D.20710>:
  <D.20711>:
  <D.20712>:
  if (strict != 0) goto <D.24353>; else goto <D.24354>;
  <D.24353>:
  D.24355 = candidate->type;
  D.24356 = D.24355 + 250;
  D.24357 = D.24356 <= 1;
  D.24358 = D.24355 == 3;
  D.24359 = D.24357 | D.24358;
  D.24339 = (gboolean) D.24359;
  return D.24339;
  <D.24354>:
  <D.20713>:
  <D.20714>:
  {
    gboolean is_native_int;
    gboolean is_int4;

    D.24344 = candidate->type;
    D.24360 = D.24344 + 232;
    D.24361 = D.24360 <= 1;
    is_native_int = (gboolean) D.24361;
    D.24344 = candidate->type;
    D.24362 = D.24344 + 248;
    D.24363 = D.24362 <= 1;
    is_int4 = (gboolean) D.24363;
    if (strict != 0) goto <D.24364>; else goto <D.24365>;
    <D.24364>:
    D.24366 = is_native_int | is_int4;
    D.24367 = D.24366 != 0;
    D.24339 = (gboolean) D.24367;
    return D.24339;
    <D.24365>:
    if (is_native_int != 0) goto <D.24369>; else goto <D.24372>;
    <D.24372>:
    D.24373 = get_stack_type (candidate);
    if (D.24373 == 1) goto <D.24369>; else goto <D.24370>;
    <D.24369>:
    iftmp.49 = 1;
    goto <D.24371>;
    <D.24370>:
    iftmp.49 = 0;
    <D.24371>:
    D.24339 = iftmp.49;
    return D.24339;
  }
  <D.20717>:
  <D.20718>:
  D.24344 = candidate->type;
  D.24374 = D.24344 + 246;
  D.24375 = D.24374 <= 1;
  D.24339 = (gboolean) D.24375;
  return D.24339;
  <D.20719>:
  <D.20720>:
  if (strict != 0) goto <D.24376>; else goto <D.24377>;
  <D.24376>:
  D.24344 = candidate->type;
  D.24342 = target->type;
  D.24378 = D.24344 == D.24342;
  D.24339 = (gboolean) D.24378;
  return D.24339;
  <D.24377>:
  D.24344 = candidate->type;
  D.24379 = D.24344 + 244;
  D.24380 = D.24379 <= 1;
  D.24339 = (gboolean) D.24380;
  return D.24339;
  <D.20721>:
  <D.20722>:
  {
    gboolean is_native_int;
    gboolean is_int4;

    D.24344 = candidate->type;
    D.24360 = D.24344 + 232;
    D.24361 = D.24360 <= 1;
    is_native_int = (gboolean) D.24361;
    D.24344 = candidate->type;
    D.24362 = D.24344 + 248;
    D.24363 = D.24362 <= 1;
    is_int4 = (gboolean) D.24363;
    if (strict != 0) goto <D.24381>; else goto <D.24382>;
    <D.24381>:
    D.24383 = is_native_int | is_int4;
    D.24384 = D.24383 != 0;
    D.24339 = (gboolean) D.24384;
    return D.24339;
    <D.24382>:
    if (is_native_int != 0) goto <D.24386>; else goto <D.24389>;
    <D.24389>:
    D.24390 = get_stack_type (candidate);
    if (D.24390 == 1) goto <D.24386>; else goto <D.24387>;
    <D.24386>:
    iftmp.50 = 1;
    goto <D.24388>;
    <D.24387>:
    iftmp.50 = 0;
    <D.24388>:
    D.24339 = iftmp.50;
    return D.24339;
  }
  <D.20725>:
  D.24344 = candidate->type;
  if (D.24344 != 15) goto <D.24391>; else goto <D.24392>;
  <D.24391>:
  D.24339 = 0;
  return D.24339;
  <D.24392>:
  D.24393 = target->data.type;
  D.24394 = candidate->data.type;
  D.24339 = verify_type_compatibility_full (ctx, D.24393, D.24394, 1);
  return D.24339;
  <D.20726>:
  {
    struct MonoMethodSignature * left;
    struct MonoMethodSignature * right;

    D.24344 = candidate->type;
    if (D.24344 != 27) goto <D.24395>; else goto <D.24396>;
    <D.24395>:
    D.24339 = 0;
    return D.24339;
    <D.24396>:
    left = mono_type_get_signature (target);
    right = mono_type_get_signature (candidate);
    D.24400 = mono_metadata_signature_equal (left, right);
    if (D.24400 != 0) goto <D.24401>; else goto <D.24398>;
    <D.24401>:
    D.24402 = BIT_FIELD_REF <*left, 8, 80>;
    D.24403 = BIT_FIELD_REF <*right, 8, 80>;
    D.24404 = D.24402 ^ D.24403;
    D.24405 = D.24404 & 63;
    if (D.24405 == 0) goto <D.24406>; else goto <D.24398>;
    <D.24406>:
    iftmp.51 = 1;
    goto <D.24399>;
    <D.24398>:
    iftmp.51 = 0;
    <D.24399>:
    D.24339 = iftmp.51;
    return D.24339;
  }
  <D.20729>:
  {
    struct MonoClass * target_klass;
    struct MonoClass * candidate_klass;

    D.24407 = mono_type_is_enum_type (target);
    if (D.24407 != 0) goto <D.24408>; else goto <D.24409>;
    <D.24408>:
    target = mono_type_get_underlying_type_any (target);
    if (target == 0B) goto <D.24410>; else goto <D.24411>;
    <D.24410>:
    D.24339 = 0;
    return D.24339;
    <D.24411>:
    goto handle_enum;
    <D.24409>:
    D.24412 = mono_type_is_generic_argument (original_candidate);
    if (D.24412 != 0) goto <D.24413>; else goto <D.24414>;
    <D.24413>:
    D.24339 = 0;
    return D.24339;
    <D.24414>:
    target_klass = mono_class_from_mono_type (target);
    candidate_klass = mono_class_from_mono_type (candidate);
    D.24415 = mono_class_is_nullable (target_klass);
    if (D.24415 != 0) goto <D.24416>; else goto <D.24417>;
    <D.24416>:
    D.24418 = mono_class_is_nullable (candidate_klass);
    if (D.24418 == 0) goto <D.24419>; else goto <D.24420>;
    <D.24419>:
    D.24339 = 0;
    return D.24339;
    <D.24420>:
    D.24421 = target_klass == candidate_klass;
    D.24339 = (gboolean) D.24421;
    return D.24339;
    <D.24417>:
    D.24339 = verifier_class_is_assignable_from (target_klass, candidate_klass);
    return D.24339;
  }
  <D.20732>:
  D.24344 = candidate->type;
  D.24422 = D.24344 == 14;
  D.24339 = (gboolean) D.24422;
  return D.24339;
  <D.20733>:
  D.24423 = mono_type_is_generic_argument (original_candidate);
  if (D.24423 != 0) goto <D.24424>; else goto <D.24425>;
  <D.24424>:
  D.24339 = 0;
  return D.24339;
  <D.24425>:
  D.24344 = candidate->type;
  if (D.24344 == 17) goto <D.24426>; else goto <D.24427>;
  <D.24426>:
  D.24339 = 0;
  return D.24339;
  <D.24427>:
  D.24428 = target->data.klass;
  D.24429 = mono_class_from_mono_type (original_candidate);
  D.24339 = verifier_class_is_assignable_from (D.24428, D.24429);
  return D.24339;
  <D.20734>:
  D.24339 = mono_type_is_reference (candidate);
  return D.24339;
  <D.20735>:
  {
    struct MonoClass * left;
    struct MonoClass * right;

    D.24344 = candidate->type;
    if (D.24344 != 29) goto <D.24430>; else goto <D.24431>;
    <D.24430>:
    D.24339 = 0;
    return D.24339;
    <D.24431>:
    left = mono_class_from_mono_type (target);
    right = mono_class_from_mono_type (candidate);
    D.24339 = verifier_class_is_assignable_from (left, right);
    return D.24339;
  }
  <D.20738>:
  D.24344 = candidate->type;
  if (D.24344 != 20) goto <D.24432>; else goto <D.24433>;
  <D.24432>:
  D.24339 = 0;
  return D.24339;
  <D.24433>:
  D.24339 = is_array_type_compatible (target, candidate);
  return D.24339;
  <D.20739>:
  D.24344 = candidate->type;
  D.24434 = D.24344 == 22;
  D.24339 = (gboolean) D.24434;
  return D.24339;
  <D.20740>:
  {
    struct MonoClass * target_klass;
    struct MonoClass * candidate_klass;

    D.24344 = candidate->type;
    if (D.24344 == 18) goto <D.24435>; else goto <D.24436>;
    <D.24435>:
    D.24339 = 0;
    return D.24339;
    <D.24436>:
    target_klass = mono_class_from_mono_type (target);
    candidate_klass = mono_class_from_mono_type (candidate);
    if (target_klass == candidate_klass) goto <D.24437>; else goto <D.24438>;
    <D.24437>:
    D.24339 = 1;
    return D.24339;
    <D.24438>:
    D.24439 = mono_type_is_enum_type (target);
    if (D.24439 != 0) goto <D.24440>; else goto <D.24441>;
    <D.24440>:
    target = mono_type_get_underlying_type_any (target);
    if (target == 0B) goto <D.24442>; else goto <D.24443>;
    <D.24442>:
    D.24339 = 0;
    return D.24339;
    <D.24443>:
    goto handle_enum;
    <D.24441>:
    D.24339 = 0;
    return D.24339;
  }
  <D.20743>:
  D.24344 = candidate->type;
  if (D.24344 != 19) goto <D.24444>; else goto <D.24445>;
  <D.24444>:
  D.24339 = 0;
  return D.24339;
  <D.24445>:
  D.24446 = candidate->data.generic_param;
  D.24447 = D.24446->num;
  D.24448 = target->data.generic_param;
  D.24449 = D.24448->num;
  D.24450 = D.24447 == D.24449;
  D.24339 = (gboolean) D.24450;
  return D.24339;
  <D.20744>:
  D.24344 = candidate->type;
  if (D.24344 != 30) goto <D.24451>; else goto <D.24452>;
  <D.24451>:
  D.24339 = 0;
  return D.24339;
  <D.24452>:
  D.24446 = candidate->data.generic_param;
  D.24447 = D.24446->num;
  D.24448 = target->data.generic_param;
  D.24449 = D.24448->num;
  D.24450 = D.24447 == D.24449;
  D.24339 = (gboolean) D.24450;
  return D.24339;
  <D.20745>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "verify.c", 2389);
  D.24339 = 0;
  return D.24339;
  D.24339 = 1;
  return D.24339;
}


stack_slot_is_boxed_value (struct ILStackDesc * value)
{
  gboolean D.24454;
  int D.24455;
  int D.24456;
  _Bool D.24457;

  D.24455 = value->stype;
  D.24456 = D.24455 & 4096;
  D.24457 = D.24456 != 0;
  D.24454 = (gboolean) D.24457;
  return D.24454;
}


is_compatible_boxed_valuetype (struct VerifyContext * ctx, struct MonoType * type, struct MonoType * candidate, struct ILStackDesc * stack, gboolean strict)
{
  int D.24459;
  gboolean D.24462;
  unsigned char D.24465;
  unsigned char D.24466;
  unsigned char D.24468;
  unsigned char D.24469;
  int D.24470;
  struct MonoGenericParamInfo * iftmp.52;
  struct MonoGenericContainer * D.24476;
  struct MonoClass * D.24480;
  int D.24481;
  int D.24485;
  int iftmp.53;
  int D.24493;
  struct MonoClass * D.24495;
  struct MonoClass * D.24496;
  int D.24497;

  D.24459 = stack_slot_is_boxed_value (stack);
  if (D.24459 == 0) goto <D.24460>; else goto <D.24461>;
  <D.24460>:
  D.24462 = 0;
  return D.24462;
  <D.24461>:
  D.24465 = BIT_FIELD_REF <*type, 8, 56>;
  D.24466 = D.24465 & 64;
  if (D.24466 != 0) goto <D.24463>; else goto <D.24467>;
  <D.24467>:
  D.24468 = BIT_FIELD_REF <*candidate, 8, 56>;
  D.24469 = D.24468 & 64;
  if (D.24469 != 0) goto <D.24463>; else goto <D.24464>;
  <D.24463>:
  D.24462 = 0;
  return D.24462;
  <D.24464>:
  D.24470 = mono_type_is_generic_argument (candidate);
  if (D.24470 != 0) goto <D.24471>; else goto <D.24472>;
  <D.24471>:
  {
    struct MonoGenericParam * param;
    struct MonoClass * * class;

    param = get_generic_param (ctx, candidate);
    if (param == 0B) goto <D.24473>; else goto <D.24474>;
    <D.24473>:
    D.24462 = 0;
    return D.24462;
    <D.24474>:
    D.24476 = param->owner;
    if (D.24476 != 0B) goto <D.24477>; else goto <D.24478>;
    <D.24477>:
    iftmp.52 = &MEM[(struct MonoGenericParamFull *)param].info;
    goto <D.24479>;
    <D.24478>:
    iftmp.52 = 0B;
    <D.24479>:
    class = iftmp.52->constraints;
    goto <D.20780>;
    <D.20779>:
    D.24480 = *class;
    D.24481 = recursive_boxed_constraint_type_check (ctx, type, D.24480, 256);
    if (D.24481 != 0) goto <D.24482>; else goto <D.24483>;
    <D.24482>:
    D.24462 = 1;
    return D.24462;
    <D.24483>:
    class = class + 4;
    <D.20780>:
    if (class != 0B) goto <D.24484>; else goto <D.20781>;
    <D.24484>:
    D.24480 = *class;
    if (D.24480 != 0B) goto <D.20779>; else goto <D.20781>;
    <D.20781>:
  }
  <D.24472>:
  D.24485 = mono_type_is_generic_argument (type);
  if (D.24485 != 0) goto <D.24486>; else goto <D.24487>;
  <D.24486>:
  D.24462 = 0;
  return D.24462;
  <D.24487>:
  if (strict == 0) goto <D.24488>; else goto <D.24489>;
  <D.24488>:
  D.24462 = 1;
  return D.24462;
  <D.24489>:
  D.24493 = mono_type_is_reference (type);
  if (D.24493 != 0) goto <D.24494>; else goto <D.24491>;
  <D.24494>:
  D.24495 = mono_class_from_mono_type (type);
  D.24496 = mono_class_from_mono_type (candidate);
  D.24497 = verifier_class_is_assignable_from (D.24495, D.24496);
  if (D.24497 != 0) goto <D.24498>; else goto <D.24491>;
  <D.24498>:
  iftmp.53 = 1;
  goto <D.24492>;
  <D.24491>:
  iftmp.53 = 0;
  <D.24492>:
  D.24462 = iftmp.53;
  return D.24462;
}


get_generic_param (struct VerifyContext * ctx, struct MonoType * param)
{
  struct MonoGenericParam * D.24500;
  unsigned char D.24501;
  struct MonoGenericContext * D.24506;
  struct MonoGenericInst * D.24507;
  <unnamed-unsigned:22> D.24509;
  int D.24510;
  int D.24511;
  gchar * D.24512;
  struct GSList * D.24513;
  struct GSList * D.24514;
  struct MonoGenericParam * D.24515;
  struct MonoType * D.24516;
  struct MonoGenericInst * D.24519;
  <unnamed-unsigned:22> D.24521;
  int D.24522;
  gchar * D.24523;
  struct GSList * D.24524;
  struct MonoType * D.24525;
  guint16 param_num;

  D.24500 = param->data.generic_param;
  param_num = D.24500->num;
  D.24501 = param->type;
  if (D.24501 == 19) goto <D.24502>; else goto <D.24503>;
  <D.24502>:
  D.24506 = ctx->generic_context;
  D.24507 = D.24506->class_inst;
  if (D.24507 == 0B) goto <D.24504>; else goto <D.24508>;
  <D.24508>:
  D.24506 = ctx->generic_context;
  D.24507 = D.24506->class_inst;
  D.24509 = D.24507->type_argc;
  D.24510 = (int) D.24509;
  D.24511 = (int) param_num;
  if (D.24510 <= D.24511) goto <D.24504>; else goto <D.24505>;
  <D.24504>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.24511 = (int) param_num;
    D.24512 = monoeg_g_strdup_printf ("Invalid generic type argument %d", D.24511);
    vinfo->info.message = D.24512;
    vinfo->exception_type = 3;
    D.24513 = ctx->list;
    D.24514 = monoeg_g_slist_prepend (D.24513, vinfo);
    ctx->list = D.24514;
  }
  ctx->valid = 0;
  D.24515 = 0B;
  return D.24515;
  <D.24505>:
  D.24506 = ctx->generic_context;
  D.24507 = D.24506->class_inst;
  D.24511 = (int) param_num;
  D.24516 = D.24507->type_argv[D.24511];
  D.24515 = D.24516->data.generic_param;
  return D.24515;
  <D.24503>:
  D.24506 = ctx->generic_context;
  D.24519 = D.24506->method_inst;
  if (D.24519 == 0B) goto <D.24517>; else goto <D.24520>;
  <D.24520>:
  D.24506 = ctx->generic_context;
  D.24519 = D.24506->method_inst;
  D.24521 = D.24519->type_argc;
  D.24522 = (int) D.24521;
  D.24511 = (int) param_num;
  if (D.24522 <= D.24511) goto <D.24517>; else goto <D.24518>;
  <D.24517>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.24511 = (int) param_num;
    D.24523 = monoeg_g_strdup_printf ("Invalid generic method argument %d", D.24511);
    vinfo->info.message = D.24523;
    vinfo->exception_type = 3;
    D.24513 = ctx->list;
    D.24524 = monoeg_g_slist_prepend (D.24513, vinfo);
    ctx->list = D.24524;
  }
  ctx->valid = 0;
  D.24515 = 0B;
  return D.24515;
  <D.24518>:
  D.24506 = ctx->generic_context;
  D.24519 = D.24506->method_inst;
  D.24511 = (int) param_num;
  D.24525 = D.24519->type_argv[D.24511];
  D.24515 = D.24525->data.generic_param;
  return D.24515;
}


recursive_boxed_constraint_type_check (struct VerifyContext * ctx, struct MonoType * type, struct MonoClass * constraint_class, int recursion_level)
{
  gboolean D.24529;
  struct MonoType * D.24530;
  int D.24531;
  int D.24534;
  struct MonoGenericParamInfo * iftmp.54;
  struct MonoGenericContainer * D.24540;
  struct MonoClass * D.24544;
  int D.24545;
  int D.24546;
  struct MonoType * constraint_type;

  constraint_type = &constraint_class->byval_arg;
  if (recursion_level <= 0) goto <D.24527>; else goto <D.24528>;
  <D.24527>:
  D.24529 = 0;
  return D.24529;
  <D.24528>:
  D.24530 = mono_type_get_type_byval (constraint_type);
  D.24531 = verify_type_compatibility_full (ctx, type, D.24530, 0);
  if (D.24531 != 0) goto <D.24532>; else goto <D.24533>;
  <D.24532>:
  D.24529 = 1;
  return D.24529;
  <D.24533>:
  D.24534 = mono_type_is_generic_argument (constraint_type);
  if (D.24534 != 0) goto <D.24535>; else goto <D.24536>;
  <D.24535>:
  {
    struct MonoGenericParam * param;
    struct MonoClass * * class;

    param = get_generic_param (ctx, constraint_type);
    if (param == 0B) goto <D.24537>; else goto <D.24538>;
    <D.24537>:
    D.24529 = 0;
    return D.24529;
    <D.24538>:
    D.24540 = param->owner;
    if (D.24540 != 0B) goto <D.24541>; else goto <D.24542>;
    <D.24541>:
    iftmp.54 = &MEM[(struct MonoGenericParamFull *)param].info;
    goto <D.24543>;
    <D.24542>:
    iftmp.54 = 0B;
    <D.24543>:
    class = iftmp.54->constraints;
    goto <D.20768>;
    <D.20767>:
    D.24544 = *class;
    D.24545 = recursion_level + -1;
    D.24546 = recursive_boxed_constraint_type_check (ctx, type, D.24544, D.24545);
    if (D.24546 != 0) goto <D.24547>; else goto <D.24548>;
    <D.24547>:
    D.24529 = 1;
    return D.24529;
    <D.24548>:
    class = class + 4;
    <D.20768>:
    if (class != 0B) goto <D.24549>; else goto <D.20769>;
    <D.24549>:
    D.24544 = *class;
    if (D.24544 != 0B) goto <D.20767>; else goto <D.20769>;
    <D.20769>:
  }
  <D.24536>:
  D.24529 = 0;
  return D.24529;
}


stack_slot_full_name (struct ILStackDesc * value)
{
  struct MonoType * D.24551;
  char * D.24552;
  char * type_name;
  char * stack_name;
  char * res;

  D.24551 = value->type;
  type_name = mono_type_full_name (D.24551);
  stack_name = stack_slot_stack_type_full_name (value);
  res = monoeg_g_strdup_printf ("%s (%s)", type_name, stack_name);
  monoeg_g_free (type_name);
  monoeg_g_free (stack_name);
  D.24552 = res;
  return D.24552;
}


stack_slot_stack_type_full_name (struct ILStackDesc * value)
{
  int D.24554;
  int D.24555;
  int D.24558;
  int D.24563;
  int D.24568;
  int D.24573;
  int D.24578;
  struct MonoType * D.24583;
  int D.24584;
  int D.24587;
  const char * D.24596;
  char * D.24597;
  struct GString * str;
  char * result;
  gboolean has_pred;
  gboolean first;

  str = monoeg_g_string_new ("");
  has_pred = 0;
  first = 1;
  D.24554 = value->stype;
  D.24555 = D.24554 & 15;
  D.24554 = value->stype;
  if (D.24555 != D.24554) goto <D.24556>; else goto <D.24557>;
  <D.24556>:
  monoeg_g_string_append (str, "[");
  D.24558 = stack_slot_is_this_pointer (value);
  if (D.24558 != 0) goto <D.24559>; else goto <D.24560>;
  <D.24559>:
  if (first == 0) goto <D.24561>; else goto <D.24562>;
  <D.24561>:
  monoeg_g_string_append (str, ", ");
  <D.24562>:
  monoeg_g_string_append (str, "this");
  first = 0;
  <D.24560>:
  D.24563 = stack_slot_is_boxed_value (value);
  if (D.24563 != 0) goto <D.24564>; else goto <D.24565>;
  <D.24564>:
  if (first == 0) goto <D.24566>; else goto <D.24567>;
  <D.24566>:
  monoeg_g_string_append (str, ", ");
  <D.24567>:
  monoeg_g_string_append (str, "boxed");
  first = 0;
  <D.24565>:
  D.24568 = stack_slot_is_null_literal (value);
  if (D.24568 != 0) goto <D.24569>; else goto <D.24570>;
  <D.24569>:
  if (first == 0) goto <D.24571>; else goto <D.24572>;
  <D.24571>:
  monoeg_g_string_append (str, ", ");
  <D.24572>:
  monoeg_g_string_append (str, "null");
  first = 0;
  <D.24570>:
  D.24573 = stack_slot_is_managed_mutability_pointer (value);
  if (D.24573 != 0) goto <D.24574>; else goto <D.24575>;
  <D.24574>:
  if (first == 0) goto <D.24576>; else goto <D.24577>;
  <D.24576>:
  monoeg_g_string_append (str, ", ");
  <D.24577>:
  monoeg_g_string_append (str, "cmmp");
  first = 0;
  <D.24575>:
  D.24578 = stack_slot_is_managed_pointer (value);
  if (D.24578 != 0) goto <D.24579>; else goto <D.24580>;
  <D.24579>:
  if (first == 0) goto <D.24581>; else goto <D.24582>;
  <D.24581>:
  monoeg_g_string_append (str, ", ");
  <D.24582>:
  monoeg_g_string_append (str, "mp");
  first = 0;
  <D.24580>:
  has_pred = 1;
  <D.24557>:
  D.24583 = value->type;
  D.24584 = mono_type_is_generic_argument (D.24583);
  if (D.24584 != 0) goto <D.24585>; else goto <D.24586>;
  <D.24585>:
  D.24587 = stack_slot_is_boxed_value (value);
  if (D.24587 == 0) goto <D.24588>; else goto <D.24589>;
  <D.24588>:
  if (has_pred == 0) goto <D.24590>; else goto <D.24591>;
  <D.24590>:
  monoeg_g_string_append (str, "[");
  <D.24591>:
  if (first == 0) goto <D.24592>; else goto <D.24593>;
  <D.24592>:
  monoeg_g_string_append (str, ", ");
  <D.24593>:
  monoeg_g_string_append (str, "unboxed");
  has_pred = 1;
  <D.24589>:
  <D.24586>:
  if (has_pred != 0) goto <D.24594>; else goto <D.24595>;
  <D.24594>:
  monoeg_g_string_append (str, "] ");
  <D.24595>:
  D.24596 = stack_slot_get_name (value);
  monoeg_g_string_append (str, D.24596);
  result = str->str;
  monoeg_g_string_free (str, 0);
  D.24597 = result;
  return D.24597;
}


stack_slot_is_this_pointer (struct ILStackDesc * value)
{
  gboolean D.24599;
  int D.24600;
  int D.24601;
  _Bool D.24602;

  D.24600 = value->stype;
  D.24601 = D.24600 & 2048;
  D.24602 = D.24601 != 0;
  D.24599 = (gboolean) D.24602;
  return D.24599;
}


stack_slot_is_managed_mutability_pointer (struct ILStackDesc * value)
{
  gboolean D.24604;
  int D.24605;
  int D.24606;
  _Bool D.24607;

  D.24605 = value->stype;
  D.24606 = D.24605 & 512;
  D.24607 = D.24606 != 0;
  D.24604 = (gboolean) D.24607;
  return D.24604;
}


stack_slot_get_name (struct ILStackDesc * value)
{
  const char * D.24609;
  int D.24610;
  int D.24611;

  D.24610 = value->stype;
  D.24611 = D.24610 & 15;
  D.24609 = type_names[D.24611];
  return D.24609;
}


stack_slot_is_managed_pointer (struct ILStackDesc * value)
{
  gboolean D.24613;
  int D.24614;
  int D.24615;
  _Bool D.24616;

  D.24614 = value->stype;
  D.24615 = D.24614 & 256;
  D.24616 = D.24615 != 0;
  D.24613 = (gboolean) D.24616;
  return D.24613;
}


do_binop (struct VerifyContext * ctx, unsigned int opcode, const unsigned char[6] * table)
{
  int D.24618;
  int D.24621;
  int D.24624;
  unsigned int idxa.55;
  unsigned int D.24628;
  const unsigned char[6] * D.24629;
  int D.24634;
  int D.24636;
  int D.24637;
  const char * D.24638;
  const char * D.24639;
  gchar * D.24640;
  struct GSList * D.24641;
  struct GSList * D.24642;
  int D.24643;
  signed char res.56;
  const char * D.24652;
  const char * D.24653;
  gchar * D.24654;
  struct GSList * D.24655;
  _Bool D.24658;
  _Bool D.24659;
  _Bool D.24660;
  int D.24669;
  struct ILStackDesc * a;
  struct ILStackDesc * b;
  struct ILStackDesc * top;
  int idxa;
  int idxb;
  int complexMerge;
  unsigned char res;

  complexMerge = 0;
  D.24618 = check_underflow (ctx, 2);
  if (D.24618 == 0) goto <D.24619>; else goto <D.24620>;
  <D.24619>:
  return;
  <D.24620>:
  b = stack_pop (ctx);
  a = stack_pop (ctx);
  idxa = stack_slot_get_underlying_type (a);
  D.24621 = stack_slot_is_managed_pointer (a);
  if (D.24621 != 0) goto <D.24622>; else goto <D.24623>;
  <D.24622>:
  idxa = 5;
  complexMerge = 1;
  <D.24623>:
  idxb = stack_slot_get_underlying_type (b);
  D.24624 = stack_slot_is_managed_pointer (b);
  if (D.24624 != 0) goto <D.24625>; else goto <D.24626>;
  <D.24625>:
  idxb = 5;
  complexMerge = 2;
  <D.24626>:
  idxa = idxa + -1;
  idxb = idxb + -1;
  idxa.55 = (unsigned int) idxa;
  D.24628 = idxa.55 * 6;
  D.24629 = table + D.24628;
  res = *D.24629[idxb];
  top = stack_push (ctx);
  if (res == 0) goto <D.24630>; else goto <D.24631>;
  <D.24630>:
  D.24634 = ctx->verifiable;
  if (D.24634 != 0) goto <D.24632>; else goto <D.24635>;
  <D.24635>:
  D.24636 = ctx->level;
  D.24637 = D.24636 & 128;
  if (D.24637 != 0) goto <D.24632>; else goto <D.24633>;
  <D.24632>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.24638 = stack_slot_get_name (a);
    D.24639 = stack_slot_get_name (b);
    D.24640 = monoeg_g_strdup_printf ("Binary instruction applyed to ill formed stack (%s x %s)", D.24638, D.24639);
    vinfo->info.message = D.24640;
    vinfo->exception_type = 4;
    D.24641 = ctx->list;
    D.24642 = monoeg_g_slist_prepend (D.24641, vinfo);
    ctx->list = D.24642;
  }
  ctx->verifiable = 0;
  D.24636 = ctx->level;
  D.24643 = D.24636 & 16;
  if (D.24643 != 0) goto <D.24644>; else goto <D.24645>;
  <D.24644>:
  ctx->valid = 0;
  <D.24645>:
  <D.24633>:
  copy_stack_value (top, a);
  return;
  <D.24631>:
  res.56 = (signed char) res;
  if (res.56 < 0) goto <D.24647>; else goto <D.24648>;
  <D.24647>:
  D.24634 = ctx->verifiable;
  if (D.24634 != 0) goto <D.24649>; else goto <D.24651>;
  <D.24651>:
  D.24636 = ctx->level;
  D.24637 = D.24636 & 128;
  if (D.24637 != 0) goto <D.24649>; else goto <D.24650>;
  <D.24649>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.24652 = stack_slot_get_name (a);
    D.24653 = stack_slot_get_name (b);
    D.24654 = monoeg_g_strdup_printf ("Binary instruction is not verifiable (%s x %s)", D.24652, D.24653);
    vinfo->info.message = D.24654;
    vinfo->exception_type = 4;
    D.24641 = ctx->list;
    D.24655 = monoeg_g_slist_prepend (D.24641, vinfo);
    ctx->list = D.24655;
  }
  ctx->verifiable = 0;
  D.24636 = ctx->level;
  D.24643 = D.24636 & 16;
  if (D.24643 != 0) goto <D.24656>; else goto <D.24657>;
  <D.24656>:
  ctx->valid = 0;
  <D.24657>:
  <D.24650>:
  res = res & 127;
  <D.24648>:
  D.24658 = complexMerge != 0;
  D.24659 = res == 5;
  D.24660 = D.24658 & D.24659;
  if (D.24660 != 0) goto <D.24661>; else goto <D.24662>;
  <D.24661>:
  if (complexMerge == 1) goto <D.24663>; else goto <D.24664>;
  <D.24663>:
  copy_stack_value (top, a);
  goto <D.24665>;
  <D.24664>:
  if (complexMerge == 2) goto <D.24666>; else goto <D.24667>;
  <D.24666>:
  copy_stack_value (top, b);
  <D.24667>:
  <D.24665>:
  goto <D.24668>;
  <D.24662>:
  D.24669 = (int) res;
  top->stype = D.24669;
  <D.24668>:
}


stack_pop (struct VerifyContext * ctx)
{
  short unsigned int D.24671;
  _Bool D.24672;
  long int D.24673;
  long int D.24674;
  struct ILStackDesc * D.24677;
  short unsigned int D.24678;
  unsigned int D.24679;
  unsigned int D.24680;
  int D.24681;
  int D.24682;
  int D.24687;
  int D.24689;
  int D.24690;
  unsigned int D.24691;
  gchar * D.24692;
  struct GSList * D.24693;
  struct GSList * D.24694;
  int D.24695;
  struct ILStackDesc * D.24698;
  struct ILStackDesc * ret;

  D.24671 = ctx->eval.size;
  D.24672 = D.24671 == 0;
  D.24673 = (long int) D.24672;
  D.24674 = __builtin_expect (D.24673, 0);
  if (D.24674 != 0) goto <D.24675>; else goto <D.24676>;
  <D.24675>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "verify.c", 1610, "ctx->eval.size > 0");
  <D.24676>:
  D.24677 = ctx->eval.stack;
  D.24671 = ctx->eval.size;
  D.24678 = D.24671 + 65535;
  ctx->eval.size = D.24678;
  D.24671 = ctx->eval.size;
  D.24679 = (unsigned int) D.24671;
  D.24680 = D.24679 * 12;
  ret = D.24677 + D.24680;
  D.24681 = ret->stype;
  D.24682 = D.24681 & 8192;
  if (D.24682 != 0) goto <D.24683>; else goto <D.24684>;
  <D.24683>:
  D.24687 = ctx->verifiable;
  if (D.24687 != 0) goto <D.24685>; else goto <D.24688>;
  <D.24688>:
  D.24689 = ctx->level;
  D.24690 = D.24689 & 128;
  if (D.24690 != 0) goto <D.24685>; else goto <D.24686>;
  <D.24685>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.24691 = ctx->ip_offset;
    D.24692 = monoeg_g_strdup_printf ("Found use of uninitialized \'this ptr\' ref at 0x%04x", D.24691);
    vinfo->info.message = D.24692;
    vinfo->exception_type = 4;
    D.24693 = ctx->list;
    D.24694 = monoeg_g_slist_prepend (D.24693, vinfo);
    ctx->list = D.24694;
  }
  ctx->verifiable = 0;
  D.24689 = ctx->level;
  D.24695 = D.24689 & 16;
  if (D.24695 != 0) goto <D.24696>; else goto <D.24697>;
  <D.24696>:
  ctx->valid = 0;
  <D.24697>:
  <D.24686>:
  <D.24684>:
  D.24698 = ret;
  return D.24698;
}


stack_slot_get_underlying_type (struct ILStackDesc * value)
{
  gint32 D.24700;
  int D.24701;

  D.24701 = value->stype;
  D.24700 = D.24701 & 15;
  return D.24700;
}


stack_pop_safe (struct VerifyContext * ctx)
{
  short unsigned int D.24703;
  _Bool D.24704;
  long int D.24705;
  long int D.24706;
  struct ILStackDesc * D.24709;
  struct ILStackDesc * D.24710;
  short unsigned int D.24711;
  unsigned int D.24712;
  unsigned int D.24713;

  D.24703 = ctx->eval.size;
  D.24704 = D.24703 == 0;
  D.24705 = (long int) D.24704;
  D.24706 = __builtin_expect (D.24705, 0);
  if (D.24706 != 0) goto <D.24707>; else goto <D.24708>;
  <D.24707>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "verify.c", 1623, "ctx->eval.size > 0");
  <D.24708>:
  D.24710 = ctx->eval.stack;
  D.24703 = ctx->eval.size;
  D.24711 = D.24703 + 65535;
  ctx->eval.size = D.24711;
  D.24703 = ctx->eval.size;
  D.24712 = (unsigned int) D.24703;
  D.24713 = D.24712 * 12;
  D.24709 = D.24710 + D.24713;
  return D.24709;
}


do_ret (struct VerifyContext * ctx)
{
  struct MonoMethodSignature * D.24715;
  unsigned char D.24716;
  int D.24719;
  struct MonoType * D.24722;
  int D.24723;
  int D.24728;
  int D.24730;
  int D.24731;
  unsigned int D.24732;
  gchar * D.24733;
  struct GSList * D.24734;
  struct GSList * D.24735;
  int D.24736;
  unsigned char D.24741;
  unsigned char D.24742;
  int D.24745;
  int D.24747;
  gchar * D.24751;
  struct GSList * D.24752;
  short unsigned int D.24755;
  int D.24761;
  gchar * D.24762;
  struct GSList * D.24763;
  struct MonoMethodHeader * D.24766;
  int D.24767;
  gchar * D.24773;
  struct GSList * D.24774;
  struct MonoType * ret;

  D.24715 = ctx->signature;
  ret = D.24715->ret;
  D.24716 = ret->type;
  if (D.24716 != 1) goto <D.24717>; else goto <D.24718>;
  <D.24717>:
  {
    struct ILStackDesc * top;

    D.24719 = check_underflow (ctx, 1);
    if (D.24719 == 0) goto <D.24720>; else goto <D.24721>;
    <D.24720>:
    return;
    <D.24721>:
    top = stack_pop (ctx);
    D.24715 = ctx->signature;
    D.24722 = D.24715->ret;
    D.24723 = verify_stack_type_compatibility (ctx, D.24722, top);
    if (D.24723 == 0) goto <D.24724>; else goto <D.24725>;
    <D.24724>:
    {
      char * ret_type;
      char * stack_type;

      D.24715 = ctx->signature;
      D.24722 = D.24715->ret;
      ret_type = mono_type_full_name (D.24722);
      stack_type = stack_slot_full_name (top);
      D.24728 = ctx->verifiable;
      if (D.24728 != 0) goto <D.24726>; else goto <D.24729>;
      <D.24729>:
      D.24730 = ctx->level;
      D.24731 = D.24730 & 128;
      if (D.24731 != 0) goto <D.24726>; else goto <D.24727>;
      <D.24726>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 8;
        D.24732 = ctx->ip_offset;
        D.24733 = monoeg_g_strdup_printf ("Incompatible return value on stack with method signature, expected \'%s\' but got \'%s\' at 0x%04x", ret_type, stack_type, D.24732);
        vinfo->info.message = D.24733;
        vinfo->exception_type = 4;
        D.24734 = ctx->list;
        D.24735 = monoeg_g_slist_prepend (D.24734, vinfo);
        ctx->list = D.24735;
      }
      ctx->verifiable = 0;
      D.24730 = ctx->level;
      D.24736 = D.24730 & 16;
      if (D.24736 != 0) goto <D.24737>; else goto <D.24738>;
      <D.24737>:
      ctx->valid = 0;
      <D.24738>:
      <D.24727>:
      monoeg_g_free (stack_type);
      monoeg_g_free (ret_type);
      return;
    }
    <D.24725>:
    D.24741 = BIT_FIELD_REF <*ret, 8, 56>;
    D.24742 = D.24741 & 64;
    if (D.24742 != 0) goto <D.24739>; else goto <D.24743>;
    <D.24743>:
    D.24716 = ret->type;
    if (D.24716 == 22) goto <D.24739>; else goto <D.24744>;
    <D.24744>:
    D.24745 = mono_type_is_value_type (ret, "System", "ArgIterator");
    if (D.24745 != 0) goto <D.24739>; else goto <D.24746>;
    <D.24746>:
    D.24747 = mono_type_is_value_type (ret, "System", "RuntimeArgumentHandle");
    if (D.24747 != 0) goto <D.24739>; else goto <D.24740>;
    <D.24739>:
    D.24728 = ctx->verifiable;
    if (D.24728 != 0) goto <D.24748>; else goto <D.24750>;
    <D.24750>:
    D.24730 = ctx->level;
    D.24731 = D.24730 & 128;
    if (D.24731 != 0) goto <D.24748>; else goto <D.24749>;
    <D.24748>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 8;
      D.24732 = ctx->ip_offset;
      D.24751 = monoeg_g_strdup_printf ("Method returns byref, TypedReference, ArgIterator or RuntimeArgumentHandle at 0x%04x", D.24732);
      vinfo->info.message = D.24751;
      vinfo->exception_type = 4;
      D.24734 = ctx->list;
      D.24752 = monoeg_g_slist_prepend (D.24734, vinfo);
      ctx->list = D.24752;
    }
    ctx->verifiable = 0;
    D.24730 = ctx->level;
    D.24736 = D.24730 & 16;
    if (D.24736 != 0) goto <D.24753>; else goto <D.24754>;
    <D.24753>:
    ctx->valid = 0;
    <D.24754>:
    <D.24749>:
    <D.24740>:
  }
  <D.24718>:
  D.24755 = ctx->eval.size;
  if (D.24755 != 0) goto <D.24756>; else goto <D.24757>;
  <D.24756>:
  D.24728 = ctx->verifiable;
  if (D.24728 != 0) goto <D.24758>; else goto <D.24760>;
  <D.24760>:
  D.24730 = ctx->level;
  D.24731 = D.24730 & 128;
  if (D.24731 != 0) goto <D.24758>; else goto <D.24759>;
  <D.24758>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.24755 = ctx->eval.size;
    D.24761 = (int) D.24755;
    D.24732 = ctx->ip_offset;
    D.24762 = monoeg_g_strdup_printf ("Stack not empty (%d) after ret at 0x%04x", D.24761, D.24732);
    vinfo->info.message = D.24762;
    vinfo->exception_type = 4;
    D.24734 = ctx->list;
    D.24763 = monoeg_g_slist_prepend (D.24734, vinfo);
    ctx->list = D.24763;
  }
  ctx->verifiable = 0;
  D.24730 = ctx->level;
  D.24736 = D.24730 & 16;
  if (D.24736 != 0) goto <D.24764>; else goto <D.24765>;
  <D.24764>:
  ctx->valid = 0;
  <D.24765>:
  <D.24759>:
  <D.24757>:
  D.24766 = ctx->header;
  D.24732 = ctx->ip_offset;
  D.24767 = in_any_block (D.24766, D.24732);
  if (D.24767 != 0) goto <D.24768>; else goto <D.24769>;
  <D.24768>:
  D.24728 = ctx->verifiable;
  if (D.24728 != 0) goto <D.24770>; else goto <D.24772>;
  <D.24772>:
  D.24730 = ctx->level;
  D.24731 = D.24730 & 128;
  if (D.24731 != 0) goto <D.24770>; else goto <D.24771>;
  <D.24770>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.24732 = ctx->ip_offset;
    D.24773 = monoeg_g_strdup_printf ("ret cannot escape exception blocks at 0x%04x", D.24732);
    vinfo->info.message = D.24773;
    vinfo->exception_type = 4;
    D.24734 = ctx->list;
    D.24774 = monoeg_g_slist_prepend (D.24734, vinfo);
    ctx->list = D.24774;
  }
  ctx->verifiable = 0;
  D.24730 = ctx->level;
  D.24736 = D.24730 & 16;
  if (D.24736 != 0) goto <D.24775>; else goto <D.24776>;
  <D.24775>:
  ctx->valid = 0;
  <D.24776>:
  <D.24771>:
  <D.24769>:
}


mono_type_is_value_type (struct MonoType * type, const char * namespace, const char * name)
{
  gboolean D.24778;
  int iftmp.57;
  unsigned char D.24782;
  int D.20087;
  struct MonoClass * D.24784;
  const char * D.24785;
  int D.20096;
  const char * D.24787;

  D.24782 = type->type;
  if (D.24782 == 17) goto <D.24783>; else goto <D.24780>;
  <D.24783>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.24784 = type->data.klass;
    D.24785 = D.24784->name_space;
    D.20087 = __builtin_strcmp (namespace, D.24785);
  }
  if (D.20087 == 0) goto <D.24786>; else goto <D.24780>;
  <D.24786>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.24784 = type->data.klass;
    D.24787 = D.24784->name;
    D.20096 = __builtin_strcmp (name, D.24787);
  }
  if (D.20096 == 0) goto <D.24788>; else goto <D.24780>;
  <D.24788>:
  iftmp.57 = 1;
  goto <D.24781>;
  <D.24780>:
  iftmp.57 = 0;
  <D.24781>:
  D.24778 = iftmp.57;
  return D.24778;
}


stack_push_val (struct VerifyContext * ctx, int stype, struct MonoType * type)
{
  struct ILStackDesc * D.24790;
  struct ILStackDesc * top;

  top = stack_push (ctx);
  top->stype = stype;
  top->type = type;
  D.24790 = top;
  return D.24790;
}


do_branch_op (struct VerifyContext * ctx, int delta, const unsigned char[6] * table)
{
  unsigned int D.24792;
  unsigned int delta.58;
  unsigned int D.24794;
  int D.24798;
  gchar * D.24799;
  struct GSList * D.24800;
  struct GSList * D.24801;
  struct MonoMethodHeader * D.24802;
  unsigned int target.59;
  int D.24804;
  int D.24807;
  int D.24809;
  int D.24810;
  gchar * D.24811;
  struct GSList * D.24812;
  int D.24813;
  gchar * D.24816;
  struct GSList * D.24817;
  int D.24819;
  int D.24822;
  int D.24825;
  int D.24831;
  int D.24833;
  unsigned int idxa.60;
  unsigned int D.24835;
  const unsigned char[6] * D.24836;
  const char * D.24842;
  const char * D.24843;
  gchar * D.24844;
  struct GSList * D.24845;
  signed char res.61;
  const char * D.24855;
  const char * D.24856;
  gchar * D.24857;
  struct GSList * D.24858;
  struct ILStackDesc * a;
  struct ILStackDesc * b;
  int idxa;
  int idxb;
  unsigned char res;
  int target;

  D.24792 = ctx->ip_offset;
  delta.58 = (unsigned int) delta;
  D.24794 = D.24792 + delta.58;
  target = (int) D.24794;
  if (target < 0) goto <D.24795>; else goto <D.24797>;
  <D.24797>:
  D.24798 = ctx->code_size;
  if (D.24798 <= target) goto <D.24795>; else goto <D.24796>;
  <D.24795>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.24792 = ctx->ip_offset;
    D.24799 = monoeg_g_strdup_printf ("Branch target out of code at 0x%04x", D.24792);
    vinfo->info.message = D.24799;
    vinfo->exception_type = 3;
    D.24800 = ctx->list;
    D.24801 = monoeg_g_slist_prepend (D.24800, vinfo);
    ctx->list = D.24801;
  }
  ctx->valid = 0;
  return;
  <D.24796>:
  D.24802 = ctx->header;
  D.24792 = ctx->ip_offset;
  target.59 = (unsigned int) target;
  D.24804 = is_valid_cmp_branch_instruction (D.24802, D.24792, target.59);
  switch (D.24804) <default: <D.24818>, case 1: <D.20963>, case 2: <D.20966>>
  <D.20963>:
  D.24807 = ctx->verifiable;
  if (D.24807 != 0) goto <D.24805>; else goto <D.24808>;
  <D.24808>:
  D.24809 = ctx->level;
  D.24810 = D.24809 & 128;
  if (D.24810 != 0) goto <D.24805>; else goto <D.24806>;
  <D.24805>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.24792 = ctx->ip_offset;
    D.24811 = monoeg_g_strdup_printf ("Branch target escapes out of exception block at 0x%04x", D.24792);
    vinfo->info.message = D.24811;
    vinfo->exception_type = 4;
    D.24800 = ctx->list;
    D.24812 = monoeg_g_slist_prepend (D.24800, vinfo);
    ctx->list = D.24812;
  }
  ctx->verifiable = 0;
  D.24809 = ctx->level;
  D.24813 = D.24809 & 16;
  if (D.24813 != 0) goto <D.24814>; else goto <D.24815>;
  <D.24814>:
  ctx->valid = 0;
  <D.24815>:
  <D.24806>:
  goto <D.20965>;
  <D.20966>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.24792 = ctx->ip_offset;
    D.24816 = monoeg_g_strdup_printf ("Branch target escapes out of exception block at 0x%04x", D.24792);
    vinfo->info.message = D.24816;
    vinfo->exception_type = 3;
    D.24800 = ctx->list;
    D.24817 = monoeg_g_slist_prepend (D.24800, vinfo);
    ctx->list = D.24817;
  }
  ctx->valid = 0;
  return;
  <D.24818>:
  <D.20965>:
  ctx->target = target;
  D.24819 = check_underflow (ctx, 2);
  if (D.24819 == 0) goto <D.24820>; else goto <D.24821>;
  <D.24820>:
  return;
  <D.24821>:
  b = stack_pop (ctx);
  a = stack_pop (ctx);
  idxa = stack_slot_get_underlying_type (a);
  D.24822 = stack_slot_is_managed_pointer (a);
  if (D.24822 != 0) goto <D.24823>; else goto <D.24824>;
  <D.24823>:
  idxa = 5;
  <D.24824>:
  idxb = stack_slot_get_underlying_type (b);
  D.24825 = stack_slot_is_managed_pointer (b);
  if (D.24825 != 0) goto <D.24826>; else goto <D.24827>;
  <D.24826>:
  idxb = 5;
  <D.24827>:
  D.24831 = stack_slot_is_complex_type_not_reference_type (a);
  if (D.24831 != 0) goto <D.24828>; else goto <D.24832>;
  <D.24832>:
  D.24833 = stack_slot_is_complex_type_not_reference_type (b);
  if (D.24833 != 0) goto <D.24828>; else goto <D.24829>;
  <D.24828>:
  res = 0;
  goto <D.24830>;
  <D.24829>:
  idxa = idxa + -1;
  idxb = idxb + -1;
  idxa.60 = (unsigned int) idxa;
  D.24835 = idxa.60 * 6;
  D.24836 = table + D.24835;
  res = *D.24836[idxb];
  <D.24830>:
  if (res == 0) goto <D.24837>; else goto <D.24838>;
  <D.24837>:
  D.24807 = ctx->verifiable;
  if (D.24807 != 0) goto <D.24839>; else goto <D.24841>;
  <D.24841>:
  D.24809 = ctx->level;
  D.24810 = D.24809 & 128;
  if (D.24810 != 0) goto <D.24839>; else goto <D.24840>;
  <D.24839>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.24842 = stack_slot_get_name (a);
    D.24843 = stack_slot_get_name (b);
    D.24792 = ctx->ip_offset;
    D.24844 = monoeg_g_strdup_printf ("Compare and Branch instruction applyed to ill formed stack (%s x %s) at 0x%04x", D.24842, D.24843, D.24792);
    vinfo->info.message = D.24844;
    vinfo->exception_type = 4;
    D.24800 = ctx->list;
    D.24845 = monoeg_g_slist_prepend (D.24800, vinfo);
    ctx->list = D.24845;
  }
  ctx->verifiable = 0;
  D.24809 = ctx->level;
  D.24813 = D.24809 & 16;
  if (D.24813 != 0) goto <D.24846>; else goto <D.24847>;
  <D.24846>:
  ctx->valid = 0;
  <D.24847>:
  <D.24840>:
  goto <D.24848>;
  <D.24838>:
  res.61 = (signed char) res;
  if (res.61 < 0) goto <D.24850>; else goto <D.24851>;
  <D.24850>:
  D.24807 = ctx->verifiable;
  if (D.24807 != 0) goto <D.24852>; else goto <D.24854>;
  <D.24854>:
  D.24809 = ctx->level;
  D.24810 = D.24809 & 128;
  if (D.24810 != 0) goto <D.24852>; else goto <D.24853>;
  <D.24852>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.24855 = stack_slot_get_name (a);
    D.24856 = stack_slot_get_name (b);
    D.24792 = ctx->ip_offset;
    D.24857 = monoeg_g_strdup_printf ("Compare and Branch instruction is not verifiable (%s x %s) at 0x%04x", D.24855, D.24856, D.24792);
    vinfo->info.message = D.24857;
    vinfo->exception_type = 4;
    D.24800 = ctx->list;
    D.24858 = monoeg_g_slist_prepend (D.24800, vinfo);
    ctx->list = D.24858;
  }
  ctx->verifiable = 0;
  D.24809 = ctx->level;
  D.24813 = D.24809 & 16;
  if (D.24813 != 0) goto <D.24859>; else goto <D.24860>;
  <D.24859>:
  ctx->valid = 0;
  <D.24860>:
  <D.24853>:
  res = res & 127;
  <D.24851>:
  <D.24848>:
}


is_valid_cmp_branch_instruction (struct MonoMethodHeader * header, guint offset, guint target)
{
  struct MonoExceptionClause * D.24862;
  unsigned int i.62;
  unsigned int D.24864;
  unsigned int D.24867;
  unsigned int D.24870;
  unsigned int D.24873;
  unsigned int D.24874;
  int D.24878;
  unsigned int D.24879;
  int iftmp.63;
  unsigned int D.24886;
  unsigned int D.24887;
  _Bool D.24889;
  int iftmp.64;
  _Bool D.24895;
  _Bool D.24896;
  int iftmp.65;
  _Bool D.24904;
  int iftmp.66;
  _Bool D.24910;
  _Bool D.24911;
  int iftmp.67;
  unsigned int D.24918;
  _Bool D.24921;
  int iftmp.68;
  _Bool D.24928;
  _Bool D.24929;
  <unnamed-unsigned:15> D.24932;
  int D.24933;
  int i;
  struct MonoExceptionClause * clause;

  i = 0;
  goto <D.20403>;
  <D.20402>:
  D.24862 = header->clauses;
  i.62 = (unsigned int) i;
  D.24864 = i.62 * 24;
  clause = D.24862 + D.24864;
  D.24867 = clause->flags;
  if (D.24867 != 0) goto <D.24868>; else goto <D.24869>;
  <D.24868>:
  D.24870 = clause->handler_offset;
  if (D.24870 <= offset) goto <D.24871>; else goto <D.24872>;
  <D.24871>:
  D.24870 = clause->handler_offset;
  D.24873 = clause->handler_len;
  D.24874 = D.24870 + D.24873;
  if (D.24874 > offset) goto <D.24875>; else goto <D.24876>;
  <D.24875>:
  D.24870 = clause->handler_offset;
  if (D.24870 > target) goto <D.24865>; else goto <D.24877>;
  <D.24877>:
  D.24870 = clause->handler_offset;
  D.24873 = clause->handler_len;
  D.24874 = D.24870 + D.24873;
  if (D.24874 <= target) goto <D.24865>; else goto <D.24866>;
  <D.24865>:
  D.24878 = 1;
  return D.24878;
  <D.24866>:
  <D.24876>:
  <D.24872>:
  <D.24869>:
  D.24879 = clause->try_offset;
  if (D.24879 != target) goto <D.24880>; else goto <D.24881>;
  <D.24880>:
  D.24879 = clause->try_offset;
  if (D.24879 <= offset) goto <D.24885>; else goto <D.24883>;
  <D.24885>:
  D.24879 = clause->try_offset;
  D.24886 = clause->try_len;
  D.24887 = D.24879 + D.24886;
  if (D.24887 > offset) goto <D.24888>; else goto <D.24883>;
  <D.24888>:
  iftmp.63 = 1;
  goto <D.24884>;
  <D.24883>:
  iftmp.63 = 0;
  <D.24884>:
  D.24889 = (_Bool) iftmp.63;
  D.24879 = clause->try_offset;
  if (D.24879 <= target) goto <D.24893>; else goto <D.24891>;
  <D.24893>:
  D.24879 = clause->try_offset;
  D.24886 = clause->try_len;
  D.24887 = D.24879 + D.24886;
  if (D.24887 > target) goto <D.24894>; else goto <D.24891>;
  <D.24894>:
  iftmp.64 = 1;
  goto <D.24892>;
  <D.24891>:
  iftmp.64 = 0;
  <D.24892>:
  D.24895 = (_Bool) iftmp.64;
  D.24896 = D.24889 ^ D.24895;
  if (D.24896 != 0) goto <D.24897>; else goto <D.24898>;
  <D.24897>:
  D.24878 = 2;
  return D.24878;
  <D.24898>:
  <D.24881>:
  D.24870 = clause->handler_offset;
  if (D.24870 <= offset) goto <D.24902>; else goto <D.24900>;
  <D.24902>:
  D.24870 = clause->handler_offset;
  D.24873 = clause->handler_len;
  D.24874 = D.24870 + D.24873;
  if (D.24874 > offset) goto <D.24903>; else goto <D.24900>;
  <D.24903>:
  iftmp.65 = 1;
  goto <D.24901>;
  <D.24900>:
  iftmp.65 = 0;
  <D.24901>:
  D.24904 = (_Bool) iftmp.65;
  D.24870 = clause->handler_offset;
  if (D.24870 <= target) goto <D.24908>; else goto <D.24906>;
  <D.24908>:
  D.24870 = clause->handler_offset;
  D.24873 = clause->handler_len;
  D.24874 = D.24870 + D.24873;
  if (D.24874 > target) goto <D.24909>; else goto <D.24906>;
  <D.24909>:
  iftmp.66 = 1;
  goto <D.24907>;
  <D.24906>:
  iftmp.66 = 0;
  <D.24907>:
  D.24910 = (_Bool) iftmp.66;
  D.24911 = D.24904 ^ D.24910;
  if (D.24911 != 0) goto <D.24912>; else goto <D.24913>;
  <D.24912>:
  D.24878 = 2;
  return D.24878;
  <D.24913>:
  D.24867 = clause->flags;
  if (D.24867 == 1) goto <D.24917>; else goto <D.24915>;
  <D.24917>:
  D.24918 = clause->data.filter_offset;
  if (D.24918 <= offset) goto <D.24919>; else goto <D.24915>;
  <D.24919>:
  D.24870 = clause->handler_offset;
  if (D.24870 > offset) goto <D.24920>; else goto <D.24915>;
  <D.24920>:
  iftmp.67 = 1;
  goto <D.24916>;
  <D.24915>:
  iftmp.67 = 0;
  <D.24916>:
  D.24921 = (_Bool) iftmp.67;
  D.24867 = clause->flags;
  if (D.24867 == 1) goto <D.24925>; else goto <D.24923>;
  <D.24925>:
  D.24918 = clause->data.filter_offset;
  if (D.24918 <= target) goto <D.24926>; else goto <D.24923>;
  <D.24926>:
  D.24870 = clause->handler_offset;
  if (D.24870 > target) goto <D.24927>; else goto <D.24923>;
  <D.24927>:
  iftmp.68 = 1;
  goto <D.24924>;
  <D.24923>:
  iftmp.68 = 0;
  <D.24924>:
  D.24928 = (_Bool) iftmp.68;
  D.24929 = D.24921 ^ D.24928;
  if (D.24929 != 0) goto <D.24930>; else goto <D.24931>;
  <D.24930>:
  D.24878 = 2;
  return D.24878;
  <D.24931>:
  i = i + 1;
  <D.20403>:
  D.24932 = header->num_clauses;
  D.24933 = (int) D.24932;
  if (D.24933 > i) goto <D.20402>; else goto <D.20404>;
  <D.20404>:
  D.24878 = 0;
  return D.24878;
}


stack_slot_is_complex_type_not_reference_type (struct ILStackDesc * slot)
{
  gboolean D.24935;
  int iftmp.69;
  int D.24939;
  struct MonoType * D.24941;
  int D.24942;
  int D.24944;

  D.24939 = stack_slot_get_type (slot);
  if (D.24939 == 6) goto <D.24940>; else goto <D.24937>;
  <D.24940>:
  D.24941 = slot->type;
  D.24942 = mono_type_is_reference (D.24941);
  if (D.24942 == 0) goto <D.24943>; else goto <D.24937>;
  <D.24943>:
  D.24944 = stack_slot_is_boxed_value (slot);
  if (D.24944 == 0) goto <D.24945>; else goto <D.24937>;
  <D.24945>:
  iftmp.69 = 1;
  goto <D.24938>;
  <D.24937>:
  iftmp.69 = 0;
  <D.24938>:
  D.24935 = iftmp.69;
  return D.24935;
}


stack_slot_get_type (struct ILStackDesc * value)
{
  gint32 D.24947;
  int D.24948;

  D.24948 = value->stype;
  D.24947 = D.24948 & 271;
  return D.24947;
}


stack_peek (struct VerifyContext * ctx, int distance)
{
  short unsigned int D.24950;
  int D.24951;
  int D.24952;
  _Bool D.24953;
  long int D.24954;
  long int D.24955;
  struct ILStackDesc * D.24958;
  struct ILStackDesc * D.24959;
  int D.24960;
  int D.24961;
  unsigned int D.24962;
  unsigned int D.24963;

  D.24950 = ctx->eval.size;
  D.24951 = (int) D.24950;
  D.24952 = D.24951 - distance;
  D.24953 = D.24952 <= 0;
  D.24954 = (long int) D.24953;
  D.24955 = __builtin_expect (D.24954, 0);
  if (D.24955 != 0) goto <D.24956>; else goto <D.24957>;
  <D.24956>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "verify.c", 1631, "ctx->eval.size - distance > 0");
  <D.24957>:
  D.24959 = ctx->eval.stack;
  D.24950 = ctx->eval.size;
  D.24951 = (int) D.24950;
  D.24960 = D.24951 + -1;
  D.24961 = D.24960 - distance;
  D.24962 = (unsigned int) D.24961;
  D.24963 = D.24962 * 12;
  D.24958 = D.24959 + D.24963;
  return D.24958;
}


copy_stack_value (struct ILStackDesc * to, struct ILStackDesc * from)
{
  int D.24965;
  struct MonoType * D.24966;
  struct MonoMethod * D.24967;

  D.24965 = from->stype;
  to->stype = D.24965;
  D.24966 = from->type;
  to->type = D.24966;
  D.24967 = from->method;
  to->method = D.24967;
}


in_any_block (struct MonoMethodHeader * header, guint offset)
{
  struct MonoExceptionClause * D.24968;
  unsigned int i.70;
  unsigned int D.24970;
  unsigned int D.24971;
  unsigned int D.24974;
  unsigned int D.24975;
  int D.24978;
  unsigned int D.24979;
  unsigned int D.24982;
  unsigned int D.24983;
  unsigned int D.24986;
  unsigned int D.24989;
  <unnamed-unsigned:15> D.24994;
  int D.24995;
  int i;
  struct MonoExceptionClause * clause;

  i = 0;
  goto <D.20374>;
  <D.20373>:
  D.24968 = header->clauses;
  i.70 = (unsigned int) i;
  D.24970 = i.70 * 24;
  clause = D.24968 + D.24970;
  D.24971 = clause->try_offset;
  if (D.24971 <= offset) goto <D.24972>; else goto <D.24973>;
  <D.24972>:
  D.24971 = clause->try_offset;
  D.24974 = clause->try_len;
  D.24975 = D.24971 + D.24974;
  if (D.24975 > offset) goto <D.24976>; else goto <D.24977>;
  <D.24976>:
  D.24978 = 1;
  return D.24978;
  <D.24977>:
  <D.24973>:
  D.24979 = clause->handler_offset;
  if (D.24979 <= offset) goto <D.24980>; else goto <D.24981>;
  <D.24980>:
  D.24979 = clause->handler_offset;
  D.24982 = clause->handler_len;
  D.24983 = D.24979 + D.24982;
  if (D.24983 > offset) goto <D.24984>; else goto <D.24985>;
  <D.24984>:
  D.24978 = 1;
  return D.24978;
  <D.24985>:
  <D.24981>:
  D.24986 = clause->flags;
  if (D.24986 == 1) goto <D.24987>; else goto <D.24988>;
  <D.24987>:
  D.24989 = clause->data.filter_offset;
  if (D.24989 <= offset) goto <D.24990>; else goto <D.24991>;
  <D.24990>:
  D.24979 = clause->handler_offset;
  if (D.24979 > offset) goto <D.24992>; else goto <D.24993>;
  <D.24992>:
  D.24978 = 1;
  return D.24978;
  <D.24993>:
  <D.24991>:
  <D.24988>:
  i = i + 1;
  <D.20374>:
  D.24994 = header->num_clauses;
  D.24995 = (int) D.24994;
  if (D.24995 > i) goto <D.20373>; else goto <D.20375>;
  <D.20375>:
  D.24978 = 0;
  return D.24978;
}


do_invoke_method (struct VerifyContext * ctx, int method_token, gboolean virtual)
{
  unsigned int D.24997;
  int D.24998;
  const char * iftmp.71;
  unsigned int D.25007;
  struct MonoClass * D.25008;
  unsigned char D.25009;
  unsigned char D.25010;
  int D.25015;
  int D.25017;
  int D.25018;
  unsigned int D.25019;
  gchar * D.25020;
  struct GSList * D.25021;
  struct GSList * D.25022;
  int D.25023;
  short unsigned int D.25026;
  int D.25027;
  int D.25028;
  gchar * D.25034;
  struct GSList * D.25035;
  int D.25039;
  gchar * D.25045;
  struct GSList * D.25046;
  unsigned int D.25049;
  unsigned int D.25050;
  unsigned int D.25053;
  unsigned int D.25054;
  struct ILCodeDesc * D.25057;
  unsigned int D.25058;
  struct ILCodeDesc * D.25059;
  short unsigned int D.25060;
  short unsigned int D.25061;
  struct MonoImage * D.25062;
  unsigned int method_token.72;
  struct MonoGenericContext * D.25064;
  const char * D.25069;
  gchar * D.25070;
  struct GSList * D.25071;
  short unsigned int D.25072;
  int D.25073;
  <unnamed-unsigned:1> D.25074;
  int D.25075;
  int D.25076;
  struct MonoType * D.25079;
  int D.25080;
  gchar * D.25086;
  struct GSList * D.25087;
  int D.25090;
  const char * iftmp.73;
  gchar * D.25100;
  struct GSList * D.25101;
  unsigned int D.25104;
  int D.25107;
  const char * iftmp.74;
  gchar * D.25114;
  struct GSList * D.25115;
  unsigned char D.25116;
  unsigned char D.25117;
  int D.25122;
  int D.25125;
  struct MonoMethod * D.25128;
  int D.25129;
  gchar * D.25135;
  struct GSList * D.25136;
  struct MonoClass * D.25141;
  struct MonoClass * D.25142;
  gchar * D.25150;
  struct GSList * D.25151;
  int D.25156;
  int D.25157;
  gchar * D.25163;
  struct GSList * D.25164;
  struct MonoType * D.25167;
  struct MonoType * D.25168;
  int D.25169;
  int D.25170;
  int D.25173;
  int D.25178;
  gchar * D.25184;
  struct GSList * D.25185;
  _Bool D.25188;
  _Bool D.25189;
  _Bool D.25190;
  int D.25193;
  gchar * D.25199;
  struct GSList * D.25200;
  struct MonoType * D.25203;
  struct MonoType * D.25204;
  struct MonoType * D.25205;
  int D.25206;
  gchar * D.25212;
  struct GSList * D.25213;
  int D.25216;
  int D.25218;
  struct MonoClass * D.25221;
  unsigned char D.25222;
  unsigned char D.25223;
  gchar * D.25229;
  struct GSList * D.25230;
  struct MonoClass * D.25235;
  unsigned char D.25236;
  unsigned char D.25237;
  int D.25242;
  gchar * D.25248;
  struct GSList * D.25249;
  struct MonoClass * D.25254;
  unsigned char D.25255;
  unsigned char D.25256;
  int D.25259;
  gchar * D.25265;
  struct GSList * D.25266;
  int D.25273;
  int D.25275;
  gchar * D.25279;
  struct GSList * D.25280;
  int D.25283;
  gchar * D.25289;
  struct GSList * D.25290;
  int D.25293;
  struct MonoClass * D.25296;
  int D.25297;
  gchar * D.25303;
  struct GSList * D.25304;
  int D.25310;
  gchar * D.25316;
  struct GSList * D.25317;
  struct MonoType * D.25320;
  unsigned char D.25321;
  int D.25324;
  int D.25327;
  unsigned int D.25330;
  unsigned char D.25333;
  int D.21046;
  int iftmp.75;
  int D.21045;
  const char[8] * D.25339;
  unsigned char D.25340;
  int D.25341;
  unsigned char D.25342;
  int D.25343;
  _Bool D.25344;
  _Bool D.25345;
  _Bool D.25346;
  const unsigned char * D.25349;
  unsigned char D.25350;
  int D.25351;
  const unsigned char * D.25352;
  unsigned char D.25353;
  int D.25354;
  _Bool D.25355;
  _Bool D.25356;
  const unsigned char * D.25359;
  unsigned char D.25360;
  int D.25361;
  const unsigned char * D.25362;
  unsigned char D.25363;
  int D.25364;
  _Bool D.25365;
  _Bool D.25366;
  const unsigned char * D.25369;
  unsigned char D.25370;
  int D.25371;
  const unsigned char * D.25372;
  unsigned char D.25373;
  int D.25374;
  unsigned int D.25378;
  int D.25379;
  struct MonoMethodSignature * D.25382;
  struct MonoType * D.25383;
  int D.25384;
  gchar * D.25390;
  struct GSList * D.25391;
  struct MonoMethodHeader * D.25394;
  const unsigned char * D.25395;
  sizetype D.25396;
  const unsigned char * D.25397;
  unsigned char D.25398;
  gchar * D.25404;
  struct GSList * D.25405;
  int param_count;
  int i;
  struct MonoMethodSignature * sig;
  struct ILStackDesc * value;
  struct MonoMethod * method;
  gboolean virt_check_this;
  gboolean constrained;

  virt_check_this = 0;
  D.24997 = ctx->prefix_set;
  D.24998 = (int) D.24997;
  constrained = D.24998 & 8;
  if (virtual != 0) goto <D.25000>; else goto <D.25001>;
  <D.25000>:
  iftmp.71 = "callvirt";
  goto <D.25002>;
  <D.25001>:
  iftmp.71 = "call";
  <D.25002>:
  method = verifier_load_method (ctx, method_token, iftmp.71);
  if (method == 0B) goto <D.25003>; else goto <D.25004>;
  <D.25003>:
  return;
  <D.25004>:
  if (virtual != 0) goto <D.25005>; else goto <D.25006>;
  <D.25005>:
  D.24997 = ctx->prefix_set;
  D.25007 = D.24997 & 4294967287;
  ctx->prefix_set = D.25007;
  D.25008 = method->klass;
  D.25009 = BIT_FIELD_REF <*D.25008, 8, 160>;
  D.25010 = D.25009 & 8;
  if (D.25010 != 0) goto <D.25011>; else goto <D.25012>;
  <D.25011>:
  D.25015 = ctx->verifiable;
  if (D.25015 != 0) goto <D.25013>; else goto <D.25016>;
  <D.25016>:
  D.25017 = ctx->level;
  D.25018 = D.25017 & 128;
  if (D.25018 != 0) goto <D.25013>; else goto <D.25014>;
  <D.25013>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25019 = ctx->ip_offset;
    D.25020 = monoeg_g_strdup_printf ("Cannot use callvirtual with valuetype method at 0x%04x", D.25019);
    vinfo->info.message = D.25020;
    vinfo->exception_type = 4;
    D.25021 = ctx->list;
    D.25022 = monoeg_g_slist_prepend (D.25021, vinfo);
    ctx->list = D.25022;
  }
  ctx->verifiable = 0;
  D.25017 = ctx->level;
  D.25023 = D.25017 & 16;
  if (D.25023 != 0) goto <D.25024>; else goto <D.25025>;
  <D.25024>:
  ctx->valid = 0;
  <D.25025>:
  <D.25014>:
  <D.25012>:
  D.25026 = method->flags;
  D.25027 = (int) D.25026;
  D.25028 = D.25027 & 16;
  if (D.25028 != 0) goto <D.25029>; else goto <D.25030>;
  <D.25029>:
  D.25015 = ctx->verifiable;
  if (D.25015 != 0) goto <D.25031>; else goto <D.25033>;
  <D.25033>:
  D.25017 = ctx->level;
  D.25018 = D.25017 & 128;
  if (D.25018 != 0) goto <D.25031>; else goto <D.25032>;
  <D.25031>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25019 = ctx->ip_offset;
    D.25034 = monoeg_g_strdup_printf ("Cannot use callvirtual with static method at 0x%04x", D.25019);
    vinfo->info.message = D.25034;
    vinfo->exception_type = 4;
    D.25021 = ctx->list;
    D.25035 = monoeg_g_slist_prepend (D.25021, vinfo);
    ctx->list = D.25035;
  }
  ctx->verifiable = 0;
  D.25017 = ctx->level;
  D.25023 = D.25017 & 16;
  if (D.25023 != 0) goto <D.25036>; else goto <D.25037>;
  <D.25036>:
  ctx->valid = 0;
  <D.25037>:
  <D.25032>:
  <D.25030>:
  goto <D.25038>;
  <D.25006>:
  D.25026 = method->flags;
  D.25027 = (int) D.25026;
  D.25039 = D.25027 & 1024;
  if (D.25039 != 0) goto <D.25040>; else goto <D.25041>;
  <D.25040>:
  D.25015 = ctx->verifiable;
  if (D.25015 != 0) goto <D.25042>; else goto <D.25044>;
  <D.25044>:
  D.25017 = ctx->level;
  D.25018 = D.25017 & 128;
  if (D.25018 != 0) goto <D.25042>; else goto <D.25043>;
  <D.25042>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25019 = ctx->ip_offset;
    D.25045 = monoeg_g_strdup_printf ("Cannot use call with an abstract method at 0x%04x", D.25019);
    vinfo->info.message = D.25045;
    vinfo->exception_type = 4;
    D.25021 = ctx->list;
    D.25046 = monoeg_g_slist_prepend (D.25021, vinfo);
    ctx->list = D.25046;
  }
  ctx->verifiable = 0;
  D.25017 = ctx->level;
  D.25023 = D.25017 & 16;
  if (D.25023 != 0) goto <D.25047>; else goto <D.25048>;
  <D.25047>:
  ctx->valid = 0;
  <D.25048>:
  <D.25043>:
  <D.25041>:
  D.25026 = method->flags;
  D.25049 = (unsigned int) D.25026;
  D.25050 = D.25049 & 96;
  if (D.25050 == 64) goto <D.25051>; else goto <D.25052>;
  <D.25051>:
  D.25008 = method->klass;
  D.25053 = D.25008->flags;
  D.25054 = D.25053 & 256;
  if (D.25054 == 0) goto <D.25055>; else goto <D.25056>;
  <D.25055>:
  virt_check_this = 1;
  D.25057 = ctx->code;
  D.25019 = ctx->ip_offset;
  D.25058 = D.25019 * 12;
  D.25059 = D.25057 + D.25058;
  D.25057 = ctx->code;
  D.25019 = ctx->ip_offset;
  D.25058 = D.25019 * 12;
  D.25059 = D.25057 + D.25058;
  D.25060 = D.25059->flags;
  D.25061 = D.25060 | 64;
  D.25059->flags = D.25061;
  <D.25056>:
  <D.25052>:
  <D.25038>:
  D.25062 = ctx->image;
  method_token.72 = (unsigned int) method_token;
  D.25064 = ctx->generic_context;
  sig = mono_method_get_signature_full (method, D.25062, method_token.72, D.25064);
  if (sig == 0B) goto <D.25065>; else goto <D.25066>;
  <D.25065>:
  D.25062 = ctx->image;
  method_token.72 = (unsigned int) method_token;
  sig = mono_method_get_signature (method, D.25062, method_token.72);
  <D.25066>:
  if (sig == 0B) goto <D.25067>; else goto <D.25068>;
  <D.25067>:
  {
    char * name;

    D.25008 = method->klass;
    name = mono_type_get_full_name (D.25008);
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.25069 = method->name;
      D.25019 = ctx->ip_offset;
      D.25070 = monoeg_g_strdup_printf ("Could not resolve signature of %s:%s at 0x%04x", name, D.25069, D.25019);
      vinfo->info.message = D.25070;
      vinfo->exception_type = 3;
      D.25021 = ctx->list;
      D.25071 = monoeg_g_slist_prepend (D.25021, vinfo);
      ctx->list = D.25071;
    }
    ctx->valid = 0;
    monoeg_g_free (name);
    return;
  }
  <D.25068>:
  D.25072 = sig->param_count;
  D.25073 = (int) D.25072;
  D.25074 = sig->hasthis;
  D.25075 = (int) D.25074;
  param_count = D.25073 + D.25075;
  D.25076 = check_underflow (ctx, param_count);
  if (D.25076 == 0) goto <D.25077>; else goto <D.25078>;
  <D.25077>:
  return;
  <D.25078>:
  D.25072 = sig->param_count;
  D.25073 = (int) D.25072;
  i = D.25073 + -1;
  goto <D.21016>;
  <D.21015>:
  value = stack_pop (ctx);
  D.25079 = sig->params[i];
  D.25080 = verify_stack_type_compatibility (ctx, D.25079, value);
  if (D.25080 == 0) goto <D.25081>; else goto <D.25082>;
  <D.25081>:
  {
    char * stack_name;
    char * sig_name;

    stack_name = stack_slot_full_name (value);
    D.25079 = sig->params[i];
    sig_name = mono_type_full_name (D.25079);
    D.25015 = ctx->verifiable;
    if (D.25015 != 0) goto <D.25083>; else goto <D.25085>;
    <D.25085>:
    D.25017 = ctx->level;
    D.25018 = D.25017 & 128;
    if (D.25018 != 0) goto <D.25083>; else goto <D.25084>;
    <D.25083>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 8;
      D.25019 = ctx->ip_offset;
      D.25086 = monoeg_g_strdup_printf ("Incompatible parameter with function signature: Calling method with signature (%s) but for argument %d there is a (%s) on stack at 0x%04x", sig_name, i, stack_name, D.25019);
      vinfo->info.message = D.25086;
      vinfo->exception_type = 4;
      D.25021 = ctx->list;
      D.25087 = monoeg_g_slist_prepend (D.25021, vinfo);
      ctx->list = D.25087;
    }
    ctx->verifiable = 0;
    D.25017 = ctx->level;
    D.25023 = D.25017 & 16;
    if (D.25023 != 0) goto <D.25088>; else goto <D.25089>;
    <D.25088>:
    ctx->valid = 0;
    <D.25089>:
    <D.25084>:
    monoeg_g_free (stack_name);
    monoeg_g_free (sig_name);
  }
  <D.25082>:
  D.25090 = stack_slot_is_managed_mutability_pointer (value);
  if (D.25090 != 0) goto <D.25091>; else goto <D.25092>;
  <D.25091>:
  D.25015 = ctx->verifiable;
  if (D.25015 != 0) goto <D.25093>; else goto <D.25095>;
  <D.25095>:
  D.25017 = ctx->level;
  D.25018 = D.25017 & 128;
  if (D.25018 != 0) goto <D.25093>; else goto <D.25094>;
  <D.25093>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    if (virtual != 0) goto <D.25097>; else goto <D.25098>;
    <D.25097>:
    iftmp.73 = "callvirt";
    goto <D.25099>;
    <D.25098>:
    iftmp.73 = "call";
    <D.25099>:
    D.25019 = ctx->ip_offset;
    D.25100 = monoeg_g_strdup_printf ("Cannot use a readonly pointer as argument of %s at 0x%04x", iftmp.73, D.25019);
    vinfo->info.message = D.25100;
    vinfo->exception_type = 4;
    D.25021 = ctx->list;
    D.25101 = monoeg_g_slist_prepend (D.25021, vinfo);
    ctx->list = D.25101;
  }
  ctx->verifiable = 0;
  D.25017 = ctx->level;
  D.25023 = D.25017 & 16;
  if (D.25023 != 0) goto <D.25102>; else goto <D.25103>;
  <D.25102>:
  ctx->valid = 0;
  <D.25103>:
  <D.25094>:
  <D.25092>:
  D.24997 = ctx->prefix_set;
  D.25104 = D.24997 & 4;
  if (D.25104 != 0) goto <D.25105>; else goto <D.25106>;
  <D.25105>:
  D.25107 = stack_slot_is_managed_pointer (value);
  if (D.25107 != 0) goto <D.25108>; else goto <D.25109>;
  <D.25108>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    if (virtual != 0) goto <D.25111>; else goto <D.25112>;
    <D.25111>:
    iftmp.74 = "callvirt";
    goto <D.25113>;
    <D.25112>:
    iftmp.74 = "call";
    <D.25113>:
    D.25019 = ctx->ip_offset;
    D.25114 = monoeg_g_strdup_printf ("Cannot  pass a byref argument to a tail %s at 0x%04x", iftmp.74, D.25019);
    vinfo->info.message = D.25114;
    vinfo->exception_type = 3;
    D.25021 = ctx->list;
    D.25115 = monoeg_g_slist_prepend (D.25021, vinfo);
    ctx->list = D.25115;
  }
  ctx->valid = 0;
  return;
  <D.25109>:
  <D.25106>:
  i = i + -1;
  <D.21016>:
  if (i >= 0) goto <D.21015>; else goto <D.21017>;
  <D.21017>:
  D.25116 = BIT_FIELD_REF <*sig, 8, 80>;
  D.25117 = D.25116 & 64;
  if (D.25117 != 0) goto <D.25118>; else goto <D.25119>;
  <D.25118>:
  {
    struct MonoType * type;
    struct ILStackDesc copy;

    try
      {
        D.25008 = method->klass;
        type = &D.25008->byval_arg;
        D.25122 = mono_method_is_constructor (method);
        if (D.25122 != 0) goto <D.25123>; else goto <D.25120>;
        <D.25123>:
        D.25008 = method->klass;
        D.25009 = BIT_FIELD_REF <*D.25008, 8, 160>;
        D.25010 = D.25009 & 8;
        if (D.25010 == 0) goto <D.25124>; else goto <D.25120>;
        <D.25124>:
        D.25017 = ctx->level;
        D.25125 = D.25017 & 32;
        if (D.25125 == 0) goto <D.25126>; else goto <D.25127>;
        <D.25126>:
        D.25128 = ctx->method;
        D.25129 = mono_method_is_constructor (D.25128);
        if (D.25129 == 0) goto <D.25130>; else goto <D.25131>;
        <D.25130>:
        D.25015 = ctx->verifiable;
        if (D.25015 != 0) goto <D.25132>; else goto <D.25134>;
        <D.25134>:
        D.25017 = ctx->level;
        D.25018 = D.25017 & 128;
        if (D.25018 != 0) goto <D.25132>; else goto <D.25133>;
        <D.25132>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.25019 = ctx->ip_offset;
          D.25135 = monoeg_g_strdup_printf ("Cannot call a constructor outside one at 0x%04x", D.25019);
          vinfo->info.message = D.25135;
          vinfo->exception_type = 4;
          D.25021 = ctx->list;
          D.25136 = monoeg_g_slist_prepend (D.25021, vinfo);
          ctx->list = D.25136;
        }
        ctx->verifiable = 0;
        D.25017 = ctx->level;
        D.25023 = D.25017 & 16;
        if (D.25023 != 0) goto <D.25137>; else goto <D.25138>;
        <D.25137>:
        ctx->valid = 0;
        <D.25138>:
        <D.25133>:
        <D.25131>:
        <D.25127>:
        D.25017 = ctx->level;
        D.25125 = D.25017 & 32;
        if (D.25125 == 0) goto <D.25139>; else goto <D.25140>;
        <D.25139>:
        D.25008 = method->klass;
        D.25128 = ctx->method;
        D.25141 = D.25128->klass;
        D.25142 = D.25141->parent;
        if (D.25008 != D.25142) goto <D.25143>; else goto <D.25144>;
        <D.25143>:
        D.25008 = method->klass;
        D.25128 = ctx->method;
        D.25141 = D.25128->klass;
        if (D.25008 != D.25141) goto <D.25145>; else goto <D.25146>;
        <D.25145>:
        D.25015 = ctx->verifiable;
        if (D.25015 != 0) goto <D.25147>; else goto <D.25149>;
        <D.25149>:
        D.25017 = ctx->level;
        D.25018 = D.25017 & 128;
        if (D.25018 != 0) goto <D.25147>; else goto <D.25148>;
        <D.25147>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.25019 = ctx->ip_offset;
          D.25150 = monoeg_g_strdup_printf ("Cannot call a constructor of a type different from this or super at 0x%04x", D.25019);
          vinfo->info.message = D.25150;
          vinfo->exception_type = 4;
          D.25021 = ctx->list;
          D.25151 = monoeg_g_slist_prepend (D.25021, vinfo);
          ctx->list = D.25151;
        }
        ctx->verifiable = 0;
        D.25017 = ctx->level;
        D.25023 = D.25017 & 16;
        if (D.25023 != 0) goto <D.25152>; else goto <D.25153>;
        <D.25152>:
        ctx->valid = 0;
        <D.25153>:
        <D.25148>:
        <D.25146>:
        <D.25144>:
        <D.25140>:
        ctx->super_ctor_called = 1;
        value = stack_pop_safe (ctx);
        D.25017 = ctx->level;
        D.25125 = D.25017 & 32;
        if (D.25125 == 0) goto <D.25154>; else goto <D.25155>;
        <D.25154>:
        D.25156 = value->stype;
        D.25157 = D.25156 & 2048;
        if (D.25157 == 0) goto <D.25158>; else goto <D.25159>;
        <D.25158>:
        D.25015 = ctx->verifiable;
        if (D.25015 != 0) goto <D.25160>; else goto <D.25162>;
        <D.25162>:
        D.25017 = ctx->level;
        D.25018 = D.25017 & 128;
        if (D.25018 != 0) goto <D.25160>; else goto <D.25161>;
        <D.25160>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.25019 = ctx->ip_offset;
          D.25163 = monoeg_g_strdup_printf ("Invalid \'this ptr\' argument for constructor at 0x%04x", D.25019);
          vinfo->info.message = D.25163;
          vinfo->exception_type = 4;
          D.25021 = ctx->list;
          D.25164 = monoeg_g_slist_prepend (D.25021, vinfo);
          ctx->list = D.25164;
        }
        ctx->verifiable = 0;
        D.25017 = ctx->level;
        D.25023 = D.25017 & 16;
        if (D.25023 != 0) goto <D.25165>; else goto <D.25166>;
        <D.25165>:
        ctx->valid = 0;
        <D.25166>:
        <D.25161>:
        <D.25159>:
        <D.25155>:
        goto <D.25121>;
        <D.25120>:
        value = stack_pop (ctx);
        <D.25121>:
        copy_stack_value (&copy, value);
        D.25167 = copy.type;
        D.25168 = mono_type_get_type_byval (D.25167);
        copy.type = D.25168;
        D.25169 = copy.stype;
        D.25170 = D.25169 & -257;
        copy.stype = D.25170;
        if (virt_check_this != 0) goto <D.25171>; else goto <D.25172>;
        <D.25171>:
        D.25173 = stack_slot_is_this_pointer (value);
        if (D.25173 == 0) goto <D.25174>; else goto <D.25175>;
        <D.25174>:
        D.25008 = method->klass;
        D.25009 = BIT_FIELD_REF <*D.25008, 8, 160>;
        D.25010 = D.25009 & 8;
        if (D.25010 == 0) goto <D.25176>; else goto <D.25177>;
        <D.25176>:
        D.25178 = stack_slot_is_boxed_value (value);
        if (D.25178 == 0) goto <D.25179>; else goto <D.25180>;
        <D.25179>:
        D.25015 = ctx->verifiable;
        if (D.25015 != 0) goto <D.25181>; else goto <D.25183>;
        <D.25183>:
        D.25017 = ctx->level;
        D.25018 = D.25017 & 128;
        if (D.25018 != 0) goto <D.25181>; else goto <D.25182>;
        <D.25181>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.25019 = ctx->ip_offset;
          D.25184 = monoeg_g_strdup_printf ("Cannot use the call opcode with a non-final virtual method on an object different than the \'this\' pointer at 0x%04x", D.25019);
          vinfo->info.message = D.25184;
          vinfo->exception_type = 4;
          D.25021 = ctx->list;
          D.25185 = monoeg_g_slist_prepend (D.25021, vinfo);
          ctx->list = D.25185;
        }
        ctx->verifiable = 0;
        D.25017 = ctx->level;
        D.25023 = D.25017 & 16;
        if (D.25023 != 0) goto <D.25186>; else goto <D.25187>;
        <D.25186>:
        ctx->valid = 0;
        <D.25187>:
        <D.25182>:
        <D.25180>:
        <D.25177>:
        <D.25175>:
        <D.25172>:
        D.25188 = constrained != 0;
        D.25189 = virtual != 0;
        D.25190 = D.25188 & D.25189;
        if (D.25190 != 0) goto <D.25191>; else goto <D.25192>;
        <D.25191>:
        D.25193 = stack_slot_is_managed_pointer (value);
        if (D.25193 == 0) goto <D.25194>; else goto <D.25195>;
        <D.25194>:
        D.25015 = ctx->verifiable;
        if (D.25015 != 0) goto <D.25196>; else goto <D.25198>;
        <D.25198>:
        D.25017 = ctx->level;
        D.25018 = D.25017 & 128;
        if (D.25018 != 0) goto <D.25196>; else goto <D.25197>;
        <D.25196>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.25019 = ctx->ip_offset;
          D.25199 = monoeg_g_strdup_printf ("Object is not a managed pointer for a constrained call at 0x%04x", D.25019);
          vinfo->info.message = D.25199;
          vinfo->exception_type = 4;
          D.25021 = ctx->list;
          D.25200 = monoeg_g_slist_prepend (D.25021, vinfo);
          ctx->list = D.25200;
        }
        ctx->verifiable = 0;
        D.25017 = ctx->level;
        D.25023 = D.25017 & 16;
        if (D.25023 != 0) goto <D.25201>; else goto <D.25202>;
        <D.25201>:
        ctx->valid = 0;
        <D.25202>:
        <D.25197>:
        <D.25195>:
        D.25203 = value->type;
        D.25204 = mono_type_get_type_byval (D.25203);
        D.25205 = ctx->constrained_type;
        D.25206 = mono_metadata_type_equal_full (D.25204, D.25205, 1);
        if (D.25206 == 0) goto <D.25207>; else goto <D.25208>;
        <D.25207>:
        D.25015 = ctx->verifiable;
        if (D.25015 != 0) goto <D.25209>; else goto <D.25211>;
        <D.25211>:
        D.25017 = ctx->level;
        D.25018 = D.25017 & 128;
        if (D.25018 != 0) goto <D.25209>; else goto <D.25210>;
        <D.25209>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.25019 = ctx->ip_offset;
          D.25212 = monoeg_g_strdup_printf ("Object not compatible with constrained type at 0x%04x", D.25019);
          vinfo->info.message = D.25212;
          vinfo->exception_type = 4;
          D.25021 = ctx->list;
          D.25213 = monoeg_g_slist_prepend (D.25021, vinfo);
          ctx->list = D.25213;
        }
        ctx->verifiable = 0;
        D.25017 = ctx->level;
        D.25023 = D.25017 & 16;
        if (D.25023 != 0) goto <D.25214>; else goto <D.25215>;
        <D.25214>:
        ctx->valid = 0;
        <D.25215>:
        <D.25210>:
        <D.25208>:
        D.25169 = copy.stype;
        D.25216 = D.25169 | 4096;
        copy.stype = D.25216;
        goto <D.25217>;
        <D.25192>:
        D.25218 = stack_slot_is_managed_pointer (value);
        if (D.25218 != 0) goto <D.25219>; else goto <D.25220>;
        <D.25219>:
        D.25203 = value->type;
        D.25221 = mono_class_from_mono_type (D.25203);
        D.25222 = BIT_FIELD_REF <*D.25221, 8, 160>;
        D.25223 = D.25222 & 8;
        if (D.25223 == 0) goto <D.25224>; else goto <D.25225>;
        <D.25224>:
        D.25015 = ctx->verifiable;
        if (D.25015 != 0) goto <D.25226>; else goto <D.25228>;
        <D.25228>:
        D.25017 = ctx->level;
        D.25018 = D.25017 & 128;
        if (D.25018 != 0) goto <D.25226>; else goto <D.25227>;
        <D.25226>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.25019 = ctx->ip_offset;
          D.25229 = monoeg_g_strdup_printf ("Cannot call a reference type using a managed pointer to the this arg at 0x%04x", D.25019);
          vinfo->info.message = D.25229;
          vinfo->exception_type = 4;
          D.25021 = ctx->list;
          D.25230 = monoeg_g_slist_prepend (D.25021, vinfo);
          ctx->list = D.25230;
        }
        ctx->verifiable = 0;
        D.25017 = ctx->level;
        D.25023 = D.25017 & 16;
        if (D.25023 != 0) goto <D.25231>; else goto <D.25232>;
        <D.25231>:
        ctx->valid = 0;
        <D.25232>:
        <D.25227>:
        <D.25225>:
        <D.25220>:
        if (virtual == 0) goto <D.25233>; else goto <D.25234>;
        <D.25233>:
        D.25203 = value->type;
        D.25235 = mono_class_from_mono_type (D.25203);
        D.25236 = BIT_FIELD_REF <*D.25235, 8, 160>;
        D.25237 = D.25236 & 8;
        if (D.25237 != 0) goto <D.25238>; else goto <D.25239>;
        <D.25238>:
        D.25008 = method->klass;
        D.25009 = BIT_FIELD_REF <*D.25008, 8, 160>;
        D.25010 = D.25009 & 8;
        if (D.25010 == 0) goto <D.25240>; else goto <D.25241>;
        <D.25240>:
        D.25242 = stack_slot_is_boxed_value (value);
        if (D.25242 == 0) goto <D.25243>; else goto <D.25244>;
        <D.25243>:
        D.25015 = ctx->verifiable;
        if (D.25015 != 0) goto <D.25245>; else goto <D.25247>;
        <D.25247>:
        D.25017 = ctx->level;
        D.25018 = D.25017 & 128;
        if (D.25018 != 0) goto <D.25245>; else goto <D.25246>;
        <D.25245>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.25019 = ctx->ip_offset;
          D.25248 = monoeg_g_strdup_printf ("Cannot call a valuetype baseclass at 0x%04x", D.25019);
          vinfo->info.message = D.25248;
          vinfo->exception_type = 4;
          D.25021 = ctx->list;
          D.25249 = monoeg_g_slist_prepend (D.25021, vinfo);
          ctx->list = D.25249;
        }
        ctx->verifiable = 0;
        D.25017 = ctx->level;
        D.25023 = D.25017 & 16;
        if (D.25023 != 0) goto <D.25250>; else goto <D.25251>;
        <D.25250>:
        ctx->valid = 0;
        <D.25251>:
        <D.25246>:
        <D.25244>:
        <D.25241>:
        <D.25239>:
        <D.25234>:
        if (virtual != 0) goto <D.25252>; else goto <D.25253>;
        <D.25252>:
        D.25203 = value->type;
        D.25254 = mono_class_from_mono_type (D.25203);
        D.25255 = BIT_FIELD_REF <*D.25254, 8, 160>;
        D.25256 = D.25255 & 8;
        if (D.25256 != 0) goto <D.25257>; else goto <D.25258>;
        <D.25257>:
        D.25259 = stack_slot_is_boxed_value (value);
        if (D.25259 == 0) goto <D.25260>; else goto <D.25261>;
        <D.25260>:
        D.25015 = ctx->verifiable;
        if (D.25015 != 0) goto <D.25262>; else goto <D.25264>;
        <D.25264>:
        D.25017 = ctx->level;
        D.25018 = D.25017 & 128;
        if (D.25018 != 0) goto <D.25262>; else goto <D.25263>;
        <D.25262>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.25019 = ctx->ip_offset;
          D.25265 = monoeg_g_strdup_printf ("Cannot use a valuetype with callvirt at 0x%04x", D.25019);
          vinfo->info.message = D.25265;
          vinfo->exception_type = 4;
          D.25021 = ctx->list;
          D.25266 = monoeg_g_slist_prepend (D.25021, vinfo);
          ctx->list = D.25266;
        }
        ctx->verifiable = 0;
        D.25017 = ctx->level;
        D.25023 = D.25017 & 16;
        if (D.25023 != 0) goto <D.25267>; else goto <D.25268>;
        <D.25267>:
        ctx->valid = 0;
        <D.25268>:
        <D.25263>:
        <D.25261>:
        <D.25258>:
        <D.25253>:
        D.25008 = method->klass;
        D.25009 = BIT_FIELD_REF <*D.25008, 8, 160>;
        D.25010 = D.25009 & 8;
        if (D.25010 != 0) goto <D.25271>; else goto <D.25272>;
        <D.25271>:
        D.25273 = stack_slot_is_boxed_value (value);
        if (D.25273 != 0) goto <D.25269>; else goto <D.25274>;
        <D.25274>:
        D.25275 = stack_slot_is_managed_pointer (value);
        if (D.25275 == 0) goto <D.25269>; else goto <D.25270>;
        <D.25269>:
        D.25015 = ctx->verifiable;
        if (D.25015 != 0) goto <D.25276>; else goto <D.25278>;
        <D.25278>:
        D.25017 = ctx->level;
        D.25018 = D.25017 & 128;
        if (D.25018 != 0) goto <D.25276>; else goto <D.25277>;
        <D.25276>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.25019 = ctx->ip_offset;
          D.25279 = monoeg_g_strdup_printf ("Cannot use a boxed or literal valuetype to call a valuetype method at 0x%04x", D.25019);
          vinfo->info.message = D.25279;
          vinfo->exception_type = 4;
          D.25021 = ctx->list;
          D.25280 = monoeg_g_slist_prepend (D.25021, vinfo);
          ctx->list = D.25280;
        }
        ctx->verifiable = 0;
        D.25017 = ctx->level;
        D.25023 = D.25017 & 16;
        if (D.25023 != 0) goto <D.25281>; else goto <D.25282>;
        <D.25281>:
        ctx->valid = 0;
        <D.25282>:
        <D.25277>:
        <D.25270>:
        <D.25272>:
        <D.25217>:
        D.25283 = verify_stack_type_compatibility (ctx, type, &copy);
        if (D.25283 == 0) goto <D.25284>; else goto <D.25285>;
        <D.25284>:
        {
          char * expected;
          char * effective;
          char * method_name;

          expected = mono_type_full_name (type);
          effective = stack_slot_full_name (&copy);
          method_name = mono_method_full_name (method, 1);
          D.25015 = ctx->verifiable;
          if (D.25015 != 0) goto <D.25286>; else goto <D.25288>;
          <D.25288>:
          D.25017 = ctx->level;
          D.25018 = D.25017 & 128;
          if (D.25018 != 0) goto <D.25286>; else goto <D.25287>;
          <D.25286>:
          {
            struct MonoVerifyInfoExtended * vinfo;

            vinfo = monoeg_malloc (12);
            vinfo->info.status = 8;
            D.25019 = ctx->ip_offset;
            D.25289 = monoeg_g_strdup_printf ("Incompatible this argument on stack with method signature expected \'%s\' but got \'%s\' for a call to \'%s\' at 0x%04x", expected, effective, method_name, D.25019);
            vinfo->info.message = D.25289;
            vinfo->exception_type = 4;
            D.25021 = ctx->list;
            D.25290 = monoeg_g_slist_prepend (D.25021, vinfo);
            ctx->list = D.25290;
          }
          ctx->verifiable = 0;
          D.25017 = ctx->level;
          D.25023 = D.25017 & 16;
          if (D.25023 != 0) goto <D.25291>; else goto <D.25292>;
          <D.25291>:
          ctx->valid = 0;
          <D.25292>:
          <D.25287>:
          monoeg_g_free (method_name);
          monoeg_g_free (effective);
          monoeg_g_free (expected);
        }
        <D.25285>:
        D.25017 = ctx->level;
        D.25293 = D.25017 & 64;
        if (D.25293 == 0) goto <D.25294>; else goto <D.25295>;
        <D.25294>:
        D.25128 = ctx->method;
        D.25203 = value->type;
        D.25296 = mono_class_from_mono_type (D.25203);
        D.25297 = mono_method_can_access_method_full (D.25128, method, D.25296);
        if (D.25297 == 0) goto <D.25298>; else goto <D.25299>;
        <D.25298>:
        {
          char * name;

          name = mono_method_full_name (method, 1);
          D.25015 = ctx->verifiable;
          if (D.25015 != 0) goto <D.25300>; else goto <D.25302>;
          <D.25302>:
          D.25017 = ctx->level;
          D.25018 = D.25017 & 128;
          if (D.25018 != 0) goto <D.25300>; else goto <D.25301>;
          <D.25300>:
          {
            struct MonoVerifyInfoExtended * vinfo;

            vinfo = monoeg_malloc (12);
            vinfo->info.status = 8;
            D.25019 = ctx->ip_offset;
            D.25303 = monoeg_g_strdup_printf ("Method %s is not accessible at 0x%04x", name, D.25019);
            vinfo->info.message = D.25303;
            vinfo->exception_type = 9;
            D.25021 = ctx->list;
            D.25304 = monoeg_g_slist_prepend (D.25021, vinfo);
            ctx->list = D.25304;
          }
          ctx->verifiable = 0;
          D.25017 = ctx->level;
          D.25023 = D.25017 & 16;
          if (D.25023 != 0) goto <D.25305>; else goto <D.25306>;
          <D.25305>:
          ctx->valid = 0;
          <D.25306>:
          <D.25301>:
          monoeg_g_free (name);
        }
        <D.25299>:
        <D.25295>:
      }
    finally
      {
        copy = {CLOBBER};
      }
  }
  goto <D.25307>;
  <D.25119>:
  D.25017 = ctx->level;
  D.25293 = D.25017 & 64;
  if (D.25293 == 0) goto <D.25308>; else goto <D.25309>;
  <D.25308>:
  D.25128 = ctx->method;
  D.25310 = mono_method_can_access_method_full (D.25128, method, 0B);
  if (D.25310 == 0) goto <D.25311>; else goto <D.25312>;
  <D.25311>:
  {
    char * name;

    name = mono_method_full_name (method, 1);
    D.25015 = ctx->verifiable;
    if (D.25015 != 0) goto <D.25313>; else goto <D.25315>;
    <D.25315>:
    D.25017 = ctx->level;
    D.25018 = D.25017 & 128;
    if (D.25018 != 0) goto <D.25313>; else goto <D.25314>;
    <D.25313>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 8;
      D.25019 = ctx->ip_offset;
      D.25316 = monoeg_g_strdup_printf ("Method %s is not accessible at 0x%04x", name, D.25019);
      vinfo->info.message = D.25316;
      vinfo->exception_type = 9;
      D.25021 = ctx->list;
      D.25317 = monoeg_g_slist_prepend (D.25021, vinfo);
      ctx->list = D.25317;
    }
    ctx->verifiable = 0;
    D.25017 = ctx->level;
    D.25023 = D.25017 & 16;
    if (D.25023 != 0) goto <D.25318>; else goto <D.25319>;
    <D.25318>:
    ctx->valid = 0;
    <D.25319>:
    <D.25314>:
    monoeg_g_free (name);
  }
  <D.25312>:
  <D.25309>:
  <D.25307>:
  D.25320 = sig->ret;
  D.25321 = D.25320->type;
  if (D.25321 != 1) goto <D.25322>; else goto <D.25323>;
  <D.25322>:
  D.25320 = sig->ret;
  D.25324 = mono_type_is_valid_in_context (ctx, D.25320);
  if (D.25324 == 0) goto <D.25325>; else goto <D.25326>;
  <D.25325>:
  return;
  <D.25326>:
  D.25327 = check_overflow (ctx);
  if (D.25327 != 0) goto <D.25328>; else goto <D.25329>;
  <D.25328>:
  value = stack_push (ctx);
  D.25320 = sig->ret;
  set_stack_value (ctx, value, D.25320, 0);
  D.24997 = ctx->prefix_set;
  D.25330 = D.24997 & 16;
  if (D.25330 != 0) goto <D.25331>; else goto <D.25332>;
  <D.25331>:
  D.25008 = method->klass;
  D.25333 = D.25008->rank;
  if (D.25333 != 0) goto <D.25334>; else goto <D.25335>;
  <D.25334>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 7;
    if (__s2_len <= 3) goto <D.25337>; else goto <D.25338>;
    <D.25337>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = method->name;
      D.25339 = "Address";
      D.25340 = MEM[(const unsigned char *)D.25339];
      D.25341 = (int) D.25340;
      D.25342 = *__s2;
      D.25343 = (int) D.25342;
      __result = D.25341 - D.25343;
      {
        D.25344 = __s2_len != 0;
        D.25345 = __result == 0;
        D.25346 = D.25344 & D.25345;
        if (D.25346 != 0) goto <D.25347>; else goto <D.25348>;
        <D.25347>:
        D.25349 = &MEM[(void *)"Address" + 1B];
        D.25350 = *D.25349;
        D.25351 = (int) D.25350;
        D.25352 = __s2 + 1;
        D.25353 = *D.25352;
        D.25354 = (int) D.25353;
        __result = D.25351 - D.25354;
        D.25355 = __s2_len > 1;
        D.25345 = __result == 0;
        D.25356 = D.25355 & D.25345;
        if (D.25356 != 0) goto <D.25357>; else goto <D.25358>;
        <D.25357>:
        D.25359 = &MEM[(void *)"Address" + 2B];
        D.25360 = *D.25359;
        D.25361 = (int) D.25360;
        D.25362 = __s2 + 2;
        D.25363 = *D.25362;
        D.25364 = (int) D.25363;
        __result = D.25361 - D.25364;
        D.25365 = __s2_len > 2;
        D.25345 = __result == 0;
        D.25366 = D.25365 & D.25345;
        if (D.25366 != 0) goto <D.25367>; else goto <D.25368>;
        <D.25367>:
        D.25369 = &MEM[(void *)"Address" + 3B];
        D.25370 = *D.25369;
        D.25371 = (int) D.25370;
        D.25372 = __s2 + 3;
        D.25373 = *D.25372;
        D.25374 = (int) D.25373;
        __result = D.25371 - D.25374;
        <D.25368>:
        <D.25358>:
        <D.25348>:
      }
      D.21045 = __result;
    }
    iftmp.75 = -D.21045;
    goto <D.25375>;
    <D.25338>:
    D.25069 = method->name;
    iftmp.75 = __builtin_strcmp (D.25069, "Address");
    <D.25375>:
    D.21046 = iftmp.75;
  }
  if (D.21046 == 0) goto <D.25376>; else goto <D.25377>;
  <D.25376>:
  D.24997 = ctx->prefix_set;
  D.25378 = D.24997 & 4294967279;
  ctx->prefix_set = D.25378;
  D.25156 = value->stype;
  D.25379 = D.25156 | 512;
  value->stype = D.25379;
  <D.25377>:
  <D.25335>:
  <D.25332>:
  <D.25329>:
  <D.25323>:
  D.24997 = ctx->prefix_set;
  D.25104 = D.24997 & 4;
  if (D.25104 != 0) goto <D.25380>; else goto <D.25381>;
  <D.25380>:
  D.25128 = ctx->method;
  D.25382 = mono_method_signature (D.25128);
  D.25383 = D.25382->ret;
  D.25320 = sig->ret;
  D.25384 = mono_delegate_ret_equal (D.25383, D.25320);
  if (D.25384 == 0) goto <D.25385>; else goto <D.25386>;
  <D.25385>:
  D.25015 = ctx->verifiable;
  if (D.25015 != 0) goto <D.25387>; else goto <D.25389>;
  <D.25389>:
  D.25017 = ctx->level;
  D.25018 = D.25017 & 128;
  if (D.25018 != 0) goto <D.25387>; else goto <D.25388>;
  <D.25387>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25019 = ctx->ip_offset;
    D.25390 = monoeg_g_strdup_printf ("Tail call with incompatible return type at 0x%04x", D.25019);
    vinfo->info.message = D.25390;
    vinfo->exception_type = 4;
    D.25021 = ctx->list;
    D.25391 = monoeg_g_slist_prepend (D.25021, vinfo);
    ctx->list = D.25391;
  }
  ctx->verifiable = 0;
  D.25017 = ctx->level;
  D.25023 = D.25017 & 16;
  if (D.25023 != 0) goto <D.25392>; else goto <D.25393>;
  <D.25392>:
  ctx->valid = 0;
  <D.25393>:
  <D.25388>:
  <D.25386>:
  D.25394 = ctx->header;
  D.25395 = D.25394->code;
  D.25019 = ctx->ip_offset;
  D.25396 = D.25019 + 5;
  D.25397 = D.25395 + D.25396;
  D.25398 = *D.25397;
  if (D.25398 != 42) goto <D.25399>; else goto <D.25400>;
  <D.25399>:
  D.25015 = ctx->verifiable;
  if (D.25015 != 0) goto <D.25401>; else goto <D.25403>;
  <D.25403>:
  D.25017 = ctx->level;
  D.25018 = D.25017 & 128;
  if (D.25018 != 0) goto <D.25401>; else goto <D.25402>;
  <D.25401>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25019 = ctx->ip_offset;
    D.25404 = monoeg_g_strdup_printf ("Tail call not followed by ret at 0x%04x", D.25019);
    vinfo->info.message = D.25404;
    vinfo->exception_type = 4;
    D.25021 = ctx->list;
    D.25405 = monoeg_g_slist_prepend (D.25021, vinfo);
    ctx->list = D.25405;
  }
  ctx->verifiable = 0;
  D.25017 = ctx->level;
  D.25023 = D.25017 & 16;
  if (D.25023 != 0) goto <D.25406>; else goto <D.25407>;
  <D.25406>:
  ctx->valid = 0;
  <D.25407>:
  <D.25402>:
  <D.25400>:
  <D.25381>:
}


verifier_load_method (struct VerifyContext * ctx, int token, const char * opcode)
{
  struct MonoMethod * D.25409;
  unsigned char D.25410;
  unsigned char D.25411;
  unsigned int token.76;
  int D.25419;
  _Bool D.25420;
  _Bool D.25421;
  _Bool D.25422;
  int D.25424;
  struct MonoImage * D.25425;
  unsigned int token.77;
  int D.25427;
  unsigned int D.25428;
  gchar * D.25429;
  struct GSList * D.25430;
  struct GSList * D.25431;
  struct MonoMethod * D.25432;
  unsigned int token.78;
  struct MonoGenericContext * D.25434;
  struct MonoLoaderError * D.25438;
  gchar * D.25439;
  struct GSList * D.25440;
  <unnamed type> D.25441;
  struct MonoMethod * method;

  D.25409 = ctx->method;
  D.25410 = BIT_FIELD_REF <*D.25409, 8, 160>;
  D.25411 = D.25410 & 124;
  if (D.25411 != 0) goto <D.25412>; else goto <D.25413>;
  <D.25412>:
  D.25409 = ctx->method;
  token.76 = (unsigned int) token;
  method = mono_method_get_wrapper_data (D.25409, token.76);
  goto <D.25415>;
  <D.25413>:
  D.25419 = token >> 24;
  D.25420 = D.25419 != 6;
  D.25421 = D.25419 != 10;
  D.25422 = D.25420 & D.25421;
  if (D.25422 != 0) goto <D.25423>; else goto <D.25416>;
  <D.25423>:
  D.25424 = token >> 24;
  if (D.25424 != 43) goto <D.25417>; else goto <D.25416>;
  <D.25416>:
  D.25425 = ctx->image;
  token.77 = (unsigned int) token;
  D.25427 = token_bounds_check (D.25425, token.77);
  if (D.25427 == 0) goto <D.25417>; else goto <D.25418>;
  <D.25417>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.25428 = ctx->ip_offset;
    D.25429 = monoeg_g_strdup_printf ("Invalid method token 0x%08x for %s at 0x%04x", token, opcode, D.25428);
    vinfo->info.message = D.25429;
    vinfo->exception_type = 12;
    D.25430 = ctx->list;
    D.25431 = monoeg_g_slist_prepend (D.25430, vinfo);
    ctx->list = D.25431;
  }
  ctx->valid = 0;
  D.25432 = 0B;
  return D.25432;
  <D.25418>:
  D.25425 = ctx->image;
  token.78 = (unsigned int) token;
  D.25434 = ctx->generic_context;
  method = mono_get_method_full (D.25425, token.78, 0B, D.25434);
  <D.25415>:
  if (method == 0B) goto <D.25435>; else goto <D.25437>;
  <D.25437>:
  D.25438 = mono_loader_get_last_error ();
  if (D.25438 != 0B) goto <D.25435>; else goto <D.25436>;
  <D.25435>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.25428 = ctx->ip_offset;
    D.25439 = monoeg_g_strdup_printf ("Cannot load method from token 0x%08x for %s at 0x%04x", token, opcode, D.25428);
    vinfo->info.message = D.25439;
    vinfo->exception_type = 12;
    D.25430 = ctx->list;
    D.25440 = monoeg_g_slist_prepend (D.25430, vinfo);
    ctx->list = D.25440;
  }
  ctx->valid = 0;
  mono_loader_clear_error ();
  D.25432 = 0B;
  return D.25432;
  <D.25436>:
  D.25441 = mono_method_is_valid_in_context (ctx, method);
  if (D.25441 == 2) goto <D.25442>; else goto <D.25443>;
  <D.25442>:
  D.25432 = 0B;
  return D.25432;
  <D.25443>:
  D.25432 = method;
  return D.25432;
}


token_bounds_check (struct MonoImage * image, guint32 token)
{
  unsigned char D.25445;
  unsigned char D.25446;
  gboolean D.25449;
  int iftmp.79;
  unsigned int D.25453;
  <unnamed-unsigned:24> D.25454;
  unsigned int D.25455;
  unsigned int D.25456;

  D.25445 = BIT_FIELD_REF <*image, 8, 128>;
  D.25446 = D.25445 & 8;
  if (D.25446 != 0) goto <D.25447>; else goto <D.25448>;
  <D.25447>:
  D.25449 = mono_reflection_is_valid_dynamic_token (image, token);
  return D.25449;
  <D.25448>:
  D.25453 = token >> 24;
  D.25454 = image->tables[D.25453].rows;
  D.25455 = (unsigned int) D.25454;
  D.25456 = token & 16777215;
  if (D.25455 >= D.25456) goto <D.25457>; else goto <D.25451>;
  <D.25457>:
  D.25456 = token & 16777215;
  if (D.25456 != 0) goto <D.25458>; else goto <D.25451>;
  <D.25458>:
  iftmp.79 = 1;
  goto <D.25452>;
  <D.25451>:
  iftmp.79 = 0;
  <D.25452>:
  D.25449 = iftmp.79;
  return D.25449;
}


mono_method_is_valid_in_context (struct VerifyContext * ctx, struct MonoMethod * method)
{
  struct MonoClass * D.25460;
  struct MonoType * D.25461;
  int D.25462;
  verify_result_t D.25465;
  unsigned char D.25466;
  unsigned char D.25467;
  int D.25470;
  const char * D.25473;
  const char * D.25474;
  const char * D.25475;
  unsigned int D.25476;
  gchar * D.25477;
  struct GSList * D.25478;
  struct GSList * D.25479;
  int D.25480;
  int D.25485;
  int D.25487;
  int D.25488;
  gchar * D.25489;
  struct GSList * D.25490;
  int D.25491;

  D.25460 = method->klass;
  D.25461 = &D.25460->byval_arg;
  D.25462 = mono_type_is_valid_in_context (ctx, D.25461);
  if (D.25462 == 0) goto <D.25463>; else goto <D.25464>;
  <D.25463>:
  D.25465 = 2;
  return D.25465;
  <D.25464>:
  D.25466 = BIT_FIELD_REF <*method, 8, 168>;
  D.25467 = D.25466 & 16;
  if (D.25467 == 0) goto <D.25468>; else goto <D.25469>;
  <D.25468>:
  D.25465 = 0;
  return D.25465;
  <D.25469>:
  D.25470 = mono_method_is_valid_generic_instantiation (ctx, method);
  if (D.25470 == 0) goto <D.25471>; else goto <D.25472>;
  <D.25471>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.25460 = method->klass;
    D.25473 = D.25460->name_space;
    D.25460 = method->klass;
    D.25474 = D.25460->name;
    D.25475 = method->name;
    D.25476 = ctx->ip_offset;
    D.25477 = monoeg_g_strdup_printf ("Invalid generic method instantiation of method %s.%s::%s at 0x%04x", D.25473, D.25474, D.25475, D.25476);
    vinfo->info.message = D.25477;
    vinfo->exception_type = 4;
    D.25478 = ctx->list;
    D.25479 = monoeg_g_slist_prepend (D.25478, vinfo);
    ctx->list = D.25479;
  }
  ctx->valid = 0;
  D.25465 = 2;
  return D.25465;
  <D.25472>:
  D.25480 = mono_method_repect_method_constraints (ctx, method);
  if (D.25480 == 0) goto <D.25481>; else goto <D.25482>;
  <D.25481>:
  D.25485 = ctx->verifiable;
  if (D.25485 != 0) goto <D.25483>; else goto <D.25486>;
  <D.25486>:
  D.25487 = ctx->level;
  D.25488 = D.25487 & 128;
  if (D.25488 != 0) goto <D.25483>; else goto <D.25484>;
  <D.25483>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25460 = method->klass;
    D.25473 = D.25460->name_space;
    D.25460 = method->klass;
    D.25474 = D.25460->name;
    D.25475 = method->name;
    D.25476 = ctx->ip_offset;
    D.25489 = monoeg_g_strdup_printf ("Invalid generic method instantiation of method %s.%s::%s (generic args don\'t respect target\'s constraints) at 0x%04x", D.25473, D.25474, D.25475, D.25476);
    vinfo->info.message = D.25489;
    vinfo->exception_type = 4;
    D.25478 = ctx->list;
    D.25490 = monoeg_g_slist_prepend (D.25478, vinfo);
    ctx->list = D.25490;
  }
  ctx->verifiable = 0;
  D.25487 = ctx->level;
  D.25491 = D.25487 & 16;
  if (D.25491 != 0) goto <D.25492>; else goto <D.25493>;
  <D.25492>:
  ctx->valid = 0;
  <D.25493>:
  <D.25484>:
  D.25465 = 1;
  return D.25465;
  <D.25482>:
  D.25465 = 0;
  return D.25465;
}


mono_method_is_valid_generic_instantiation (struct VerifyContext * ctx, struct MonoMethod * method)
{
  struct MonoMethod * D.25495;
  gboolean D.25498;
  int D.25501;
  struct MonoGenericContext * D.25504;
  struct MonoMethodInflated * gmethod;
  struct MonoGenericInst * ginst;
  struct MonoGenericContainer * gc;

  gmethod = method;
  ginst = gmethod->context.method_inst;
  D.25495 = gmethod->declaring;
  gc = mono_method_get_generic_container (D.25495);
  if (gc == 0B) goto <D.25496>; else goto <D.25497>;
  <D.25496>:
  D.25498 = 1;
  return D.25498;
  <D.25497>:
  if (ctx != 0B) goto <D.25499>; else goto <D.25500>;
  <D.25499>:
  D.25501 = is_valid_generic_instantiation_in_context (ctx, ginst, 1);
  if (D.25501 == 0) goto <D.25502>; else goto <D.25503>;
  <D.25502>:
  D.25498 = 0;
  return D.25498;
  <D.25503>:
  <D.25500>:
  D.25504 = &gmethod->context;
  D.25498 = is_valid_generic_instantiation (gc, D.25504, ginst);
  return D.25498;
}


mono_method_repect_method_constraints (struct VerifyContext * ctx, struct MonoMethod * method)
{
  struct MonoMethod * D.25506;
  gboolean D.25507;
  int iftmp.80;
  struct MonoGenericContext * D.25513;
  int D.25514;
  struct MonoMethodInflated * gmethod;
  struct MonoGenericInst * ginst;
  struct MonoGenericContainer * gc;

  gmethod = method;
  ginst = gmethod->context.method_inst;
  D.25506 = gmethod->declaring;
  gc = mono_method_get_generic_container (D.25506);
  if (gc == 0B) goto <D.25509>; else goto <D.25512>;
  <D.25512>:
  D.25513 = &gmethod->context;
  D.25514 = generic_arguments_respect_constraints (ctx, gc, D.25513, ginst);
  if (D.25514 != 0) goto <D.25509>; else goto <D.25510>;
  <D.25509>:
  iftmp.80 = 1;
  goto <D.25511>;
  <D.25510>:
  iftmp.80 = 0;
  <D.25511>:
  D.25507 = iftmp.80;
  return D.25507;
}


do_static_branch (struct VerifyContext * ctx, int delta)
{
  unsigned int D.25516;
  unsigned int delta.81;
  unsigned int D.25518;
  int D.25522;
  gchar * D.25523;
  struct GSList * D.25524;
  struct GSList * D.25525;
  struct MonoMethodHeader * D.25526;
  unsigned int target.82;
  int D.25528;
  int D.25531;
  int D.25533;
  int D.25534;
  gchar * D.25535;
  struct GSList * D.25536;
  int D.25537;
  gchar * D.25540;
  struct GSList * D.25541;
  int target;

  D.25516 = ctx->ip_offset;
  delta.81 = (unsigned int) delta;
  D.25518 = D.25516 + delta.81;
  target = (int) D.25518;
  if (target < 0) goto <D.25519>; else goto <D.25521>;
  <D.25521>:
  D.25522 = ctx->code_size;
  if (D.25522 <= target) goto <D.25519>; else goto <D.25520>;
  <D.25519>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.25516 = ctx->ip_offset;
    D.25523 = monoeg_g_strdup_printf ("branch target out of code at 0x%04x", D.25516);
    vinfo->info.message = D.25523;
    vinfo->exception_type = 3;
    D.25524 = ctx->list;
    D.25525 = monoeg_g_slist_prepend (D.25524, vinfo);
    ctx->list = D.25525;
  }
  ctx->valid = 0;
  return;
  <D.25520>:
  D.25526 = ctx->header;
  D.25516 = ctx->ip_offset;
  target.82 = (unsigned int) target;
  D.25528 = is_valid_branch_instruction (D.25526, D.25516, target.82);
  switch (D.25528) <default: <D.25542>, case 1: <D.21431>, case 2: <D.21434>>
  <D.21431>:
  D.25531 = ctx->verifiable;
  if (D.25531 != 0) goto <D.25529>; else goto <D.25532>;
  <D.25532>:
  D.25533 = ctx->level;
  D.25534 = D.25533 & 128;
  if (D.25534 != 0) goto <D.25529>; else goto <D.25530>;
  <D.25529>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25516 = ctx->ip_offset;
    D.25535 = monoeg_g_strdup_printf ("Branch target escapes out of exception block at 0x%04x", D.25516);
    vinfo->info.message = D.25535;
    vinfo->exception_type = 4;
    D.25524 = ctx->list;
    D.25536 = monoeg_g_slist_prepend (D.25524, vinfo);
    ctx->list = D.25536;
  }
  ctx->verifiable = 0;
  D.25533 = ctx->level;
  D.25537 = D.25533 & 16;
  if (D.25537 != 0) goto <D.25538>; else goto <D.25539>;
  <D.25538>:
  ctx->valid = 0;
  <D.25539>:
  <D.25530>:
  goto <D.21433>;
  <D.21434>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.25516 = ctx->ip_offset;
    D.25540 = monoeg_g_strdup_printf ("Branch target escapes out of exception block at 0x%04x", D.25516);
    vinfo->info.message = D.25540;
    vinfo->exception_type = 3;
    D.25524 = ctx->list;
    D.25541 = monoeg_g_slist_prepend (D.25524, vinfo);
    ctx->list = D.25541;
  }
  ctx->valid = 0;
  goto <D.21433>;
  <D.25542>:
  <D.21433>:
  ctx->target = target;
}


is_valid_branch_instruction (struct MonoMethodHeader * header, guint offset, guint target)
{
  struct MonoExceptionClause * D.25544;
  unsigned int i.83;
  unsigned int D.25546;
  unsigned int D.25549;
  _Bool D.25550;
  _Bool D.25551;
  _Bool D.25552;
  unsigned int D.25555;
  unsigned int D.25557;
  unsigned int D.25558;
  int D.25563;
  unsigned int D.25564;
  int iftmp.84;
  unsigned int D.25571;
  unsigned int D.25572;
  _Bool D.25574;
  int iftmp.85;
  _Bool D.25580;
  _Bool D.25581;
  int iftmp.86;
  _Bool D.25589;
  int iftmp.87;
  _Bool D.25595;
  _Bool D.25596;
  int iftmp.88;
  unsigned int D.25602;
  unsigned int D.25604;
  _Bool D.25607;
  int iftmp.89;
  _Bool D.25614;
  _Bool D.25615;
  <unnamed-unsigned:15> D.25618;
  int D.25619;
  int i;
  struct MonoExceptionClause * clause;

  i = 0;
  goto <D.20393>;
  <D.20392>:
  D.25544 = header->clauses;
  i.83 = (unsigned int) i;
  D.25546 = i.83 * 24;
  clause = D.25544 + D.25546;
  D.25549 = clause->flags;
  D.25550 = D.25549 == 2;
  D.25551 = D.25549 == 4;
  D.25552 = D.25550 | D.25551;
  if (D.25552 != 0) goto <D.25553>; else goto <D.25554>;
  <D.25553>:
  D.25555 = clause->handler_offset;
  if (D.25555 > offset) goto <D.25547>; else goto <D.25556>;
  <D.25556>:
  D.25555 = clause->handler_offset;
  D.25557 = clause->handler_len;
  D.25558 = D.25555 + D.25557;
  if (D.25558 <= offset) goto <D.25547>; else goto <D.25548>;
  <D.25547>:
  D.25555 = clause->handler_offset;
  if (D.25555 <= target) goto <D.25559>; else goto <D.25560>;
  <D.25559>:
  D.25555 = clause->handler_offset;
  D.25557 = clause->handler_len;
  D.25558 = D.25555 + D.25557;
  if (D.25558 > target) goto <D.25561>; else goto <D.25562>;
  <D.25561>:
  D.25563 = 2;
  return D.25563;
  <D.25562>:
  <D.25560>:
  <D.25548>:
  <D.25554>:
  D.25564 = clause->try_offset;
  if (D.25564 != target) goto <D.25565>; else goto <D.25566>;
  <D.25565>:
  D.25564 = clause->try_offset;
  if (D.25564 <= offset) goto <D.25570>; else goto <D.25568>;
  <D.25570>:
  D.25564 = clause->try_offset;
  D.25571 = clause->try_len;
  D.25572 = D.25564 + D.25571;
  if (D.25572 > offset) goto <D.25573>; else goto <D.25568>;
  <D.25573>:
  iftmp.84 = 1;
  goto <D.25569>;
  <D.25568>:
  iftmp.84 = 0;
  <D.25569>:
  D.25574 = (_Bool) iftmp.84;
  D.25564 = clause->try_offset;
  if (D.25564 <= target) goto <D.25578>; else goto <D.25576>;
  <D.25578>:
  D.25564 = clause->try_offset;
  D.25571 = clause->try_len;
  D.25572 = D.25564 + D.25571;
  if (D.25572 > target) goto <D.25579>; else goto <D.25576>;
  <D.25579>:
  iftmp.85 = 1;
  goto <D.25577>;
  <D.25576>:
  iftmp.85 = 0;
  <D.25577>:
  D.25580 = (_Bool) iftmp.85;
  D.25581 = D.25574 ^ D.25580;
  if (D.25581 != 0) goto <D.25582>; else goto <D.25583>;
  <D.25582>:
  D.25563 = 1;
  return D.25563;
  <D.25583>:
  <D.25566>:
  D.25555 = clause->handler_offset;
  if (D.25555 <= offset) goto <D.25587>; else goto <D.25585>;
  <D.25587>:
  D.25555 = clause->handler_offset;
  D.25557 = clause->handler_len;
  D.25558 = D.25555 + D.25557;
  if (D.25558 > offset) goto <D.25588>; else goto <D.25585>;
  <D.25588>:
  iftmp.86 = 1;
  goto <D.25586>;
  <D.25585>:
  iftmp.86 = 0;
  <D.25586>:
  D.25589 = (_Bool) iftmp.86;
  D.25555 = clause->handler_offset;
  if (D.25555 <= target) goto <D.25593>; else goto <D.25591>;
  <D.25593>:
  D.25555 = clause->handler_offset;
  D.25557 = clause->handler_len;
  D.25558 = D.25555 + D.25557;
  if (D.25558 > target) goto <D.25594>; else goto <D.25591>;
  <D.25594>:
  iftmp.87 = 1;
  goto <D.25592>;
  <D.25591>:
  iftmp.87 = 0;
  <D.25592>:
  D.25595 = (_Bool) iftmp.87;
  D.25596 = D.25589 ^ D.25595;
  if (D.25596 != 0) goto <D.25597>; else goto <D.25598>;
  <D.25597>:
  D.25563 = 1;
  return D.25563;
  <D.25598>:
  D.25602 = clause->flags;
  if (D.25602 == 1) goto <D.25603>; else goto <D.25600>;
  <D.25603>:
  D.25604 = clause->data.filter_offset;
  if (D.25604 <= offset) goto <D.25605>; else goto <D.25600>;
  <D.25605>:
  D.25555 = clause->handler_offset;
  if (D.25555 > offset) goto <D.25606>; else goto <D.25600>;
  <D.25606>:
  iftmp.88 = 1;
  goto <D.25601>;
  <D.25600>:
  iftmp.88 = 0;
  <D.25601>:
  D.25607 = (_Bool) iftmp.88;
  D.25602 = clause->flags;
  if (D.25602 == 1) goto <D.25611>; else goto <D.25609>;
  <D.25611>:
  D.25604 = clause->data.filter_offset;
  if (D.25604 <= target) goto <D.25612>; else goto <D.25609>;
  <D.25612>:
  D.25555 = clause->handler_offset;
  if (D.25555 > target) goto <D.25613>; else goto <D.25609>;
  <D.25613>:
  iftmp.89 = 1;
  goto <D.25610>;
  <D.25609>:
  iftmp.89 = 0;
  <D.25610>:
  D.25614 = (_Bool) iftmp.89;
  D.25615 = D.25607 ^ D.25614;
  if (D.25615 != 0) goto <D.25616>; else goto <D.25617>;
  <D.25616>:
  D.25563 = 1;
  return D.25563;
  <D.25617>:
  i = i + 1;
  <D.20393>:
  D.25618 = header->num_clauses;
  D.25619 = (int) D.25618;
  if (D.25619 > i) goto <D.20392>; else goto <D.20394>;
  <D.20394>:
  D.25563 = 0;
  return D.25563;
}


do_boolean_branch_op (struct VerifyContext * ctx, int delta)
{
  unsigned int D.25621;
  unsigned int delta.90;
  unsigned int D.25623;
  int D.25627;
  gchar * D.25628;
  struct GSList * D.25629;
  struct GSList * D.25630;
  struct MonoMethodHeader * D.25631;
  unsigned int target.91;
  int D.25633;
  int D.25636;
  int D.25638;
  int D.25639;
  gchar * D.25640;
  struct GSList * D.25641;
  int D.25642;
  gchar * D.25645;
  struct GSList * D.25646;
  int D.25648;
  int D.25651;
  const char * D.25657;
  gchar * D.25658;
  struct GSList * D.25659;
  int target;
  struct ILStackDesc * top;

  D.25621 = ctx->ip_offset;
  delta.90 = (unsigned int) delta;
  D.25623 = D.25621 + delta.90;
  target = (int) D.25623;
  if (target < 0) goto <D.25624>; else goto <D.25626>;
  <D.25626>:
  D.25627 = ctx->code_size;
  if (D.25627 <= target) goto <D.25624>; else goto <D.25625>;
  <D.25624>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.25621 = ctx->ip_offset;
    D.25628 = monoeg_g_strdup_printf ("Boolean branch target out of code at 0x%04x", D.25621);
    vinfo->info.message = D.25628;
    vinfo->exception_type = 3;
    D.25629 = ctx->list;
    D.25630 = monoeg_g_slist_prepend (D.25629, vinfo);
    ctx->list = D.25630;
  }
  ctx->valid = 0;
  return;
  <D.25625>:
  D.25631 = ctx->header;
  D.25621 = ctx->ip_offset;
  target.91 = (unsigned int) target;
  D.25633 = is_valid_branch_instruction (D.25631, D.25621, target.91);
  switch (D.25633) <default: <D.25647>, case 1: <D.20942>, case 2: <D.20945>>
  <D.20942>:
  D.25636 = ctx->verifiable;
  if (D.25636 != 0) goto <D.25634>; else goto <D.25637>;
  <D.25637>:
  D.25638 = ctx->level;
  D.25639 = D.25638 & 128;
  if (D.25639 != 0) goto <D.25634>; else goto <D.25635>;
  <D.25634>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25621 = ctx->ip_offset;
    D.25640 = monoeg_g_strdup_printf ("Branch target escapes out of exception block at 0x%04x", D.25621);
    vinfo->info.message = D.25640;
    vinfo->exception_type = 4;
    D.25629 = ctx->list;
    D.25641 = monoeg_g_slist_prepend (D.25629, vinfo);
    ctx->list = D.25641;
  }
  ctx->verifiable = 0;
  D.25638 = ctx->level;
  D.25642 = D.25638 & 16;
  if (D.25642 != 0) goto <D.25643>; else goto <D.25644>;
  <D.25643>:
  ctx->valid = 0;
  <D.25644>:
  <D.25635>:
  goto <D.20944>;
  <D.20945>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.25621 = ctx->ip_offset;
    D.25645 = monoeg_g_strdup_printf ("Branch target escapes out of exception block at 0x%04x", D.25621);
    vinfo->info.message = D.25645;
    vinfo->exception_type = 3;
    D.25629 = ctx->list;
    D.25646 = monoeg_g_slist_prepend (D.25629, vinfo);
    ctx->list = D.25646;
  }
  ctx->valid = 0;
  return;
  <D.25647>:
  <D.20944>:
  ctx->target = target;
  D.25648 = check_underflow (ctx, 1);
  if (D.25648 == 0) goto <D.25649>; else goto <D.25650>;
  <D.25649>:
  return;
  <D.25650>:
  top = stack_pop (ctx);
  D.25651 = is_valid_bool_arg (top);
  if (D.25651 == 0) goto <D.25652>; else goto <D.25653>;
  <D.25652>:
  D.25636 = ctx->verifiable;
  if (D.25636 != 0) goto <D.25654>; else goto <D.25656>;
  <D.25656>:
  D.25638 = ctx->level;
  D.25639 = D.25638 & 128;
  if (D.25639 != 0) goto <D.25654>; else goto <D.25655>;
  <D.25654>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25657 = stack_slot_get_name (top);
    D.25621 = ctx->ip_offset;
    D.25658 = monoeg_g_strdup_printf ("Argument type %s not valid for brtrue/brfalse at 0x%04x", D.25657, D.25621);
    vinfo->info.message = D.25658;
    vinfo->exception_type = 4;
    D.25629 = ctx->list;
    D.25659 = monoeg_g_slist_prepend (D.25629, vinfo);
    ctx->list = D.25659;
  }
  ctx->verifiable = 0;
  D.25638 = ctx->level;
  D.25642 = D.25638 & 16;
  if (D.25642 != 0) goto <D.25660>; else goto <D.25661>;
  <D.25660>:
  ctx->valid = 0;
  <D.25661>:
  <D.25655>:
  <D.25653>:
  check_unmanaged_pointer (ctx, top);
}


is_valid_bool_arg (struct ILStackDesc * arg)
{
  int D.25665;
  int D.25667;
  int D.25669;
  gboolean D.25670;
  int D.25671;
  struct MonoType * D.25672;
  _Bool D.25673;
  long int D.25674;
  long int D.25675;
  unsigned char D.25678;
  int D.25679;
  struct MonoGenericClass * D.25680;
  struct MonoClass * D.25681;
  unsigned char D.25682;
  unsigned char D.25683;
  _Bool D.25684;

  D.25665 = stack_slot_is_managed_pointer (arg);
  if (D.25665 != 0) goto <D.25663>; else goto <D.25666>;
  <D.25666>:
  D.25667 = stack_slot_is_boxed_value (arg);
  if (D.25667 != 0) goto <D.25663>; else goto <D.25668>;
  <D.25668>:
  D.25669 = stack_slot_is_null_literal (arg);
  if (D.25669 != 0) goto <D.25663>; else goto <D.25664>;
  <D.25663>:
  D.25670 = 1;
  return D.25670;
  <D.25664>:
  D.25671 = stack_slot_get_underlying_type (arg);
  switch (D.25671) <default: <D.20468>, case 1: <D.20455>, case 2: <D.20456>, case 3: <D.20457>, case 5: <D.20458>, case 6: <D.20459>>
  <D.20455>:
  <D.20456>:
  <D.20457>:
  <D.20458>:
  D.25670 = 1;
  return D.25670;
  <D.20459>:
  D.25672 = arg->type;
  D.25673 = D.25672 == 0B;
  D.25674 = (long int) D.25673;
  D.25675 = __builtin_expect (D.25674, 0);
  if (D.25675 != 0) goto <D.25676>; else goto <D.25677>;
  <D.25676>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "verify.c", 1433, "arg->type");
  <D.25677>:
  D.25672 = arg->type;
  D.25678 = D.25672->type;
  D.25679 = (int) D.25678;
  switch (D.25679) <default: <D.25685>, case 14: <D.20461>, case 15: <D.20466>, case 18: <D.20460>, case 20: <D.20464>, case 21: <D.20467>, case 27: <D.20465>, case 28: <D.20462>, case 29: <D.20463>>
  <D.20460>:
  <D.20461>:
  <D.20462>:
  <D.20463>:
  <D.20464>:
  <D.20465>:
  <D.20466>:
  D.25670 = 1;
  return D.25670;
  <D.20467>:
  D.25672 = arg->type;
  D.25680 = D.25672->data.generic_class;
  D.25681 = D.25680->container_class;
  D.25682 = BIT_FIELD_REF <*D.25681, 8, 160>;
  D.25683 = D.25682 & 8;
  D.25684 = D.25683 == 0;
  D.25670 = (gboolean) D.25684;
  return D.25670;
  <D.25685>:
  <D.20468>:
  D.25670 = 0;
  return D.25670;
}


check_unmanaged_pointer (struct VerifyContext * ctx, struct ILStackDesc * value)
{
  int D.25687;
  int D.25692;
  int D.25694;
  int D.25695;
  unsigned int D.25696;
  gchar * D.25697;
  struct GSList * D.25698;
  struct GSList * D.25699;
  int D.25700;
  gboolean D.25703;

  D.25687 = stack_slot_get_type (value);
  if (D.25687 == 5) goto <D.25688>; else goto <D.25689>;
  <D.25688>:
  D.25692 = ctx->verifiable;
  if (D.25692 != 0) goto <D.25690>; else goto <D.25693>;
  <D.25693>:
  D.25694 = ctx->level;
  D.25695 = D.25694 & 128;
  if (D.25695 != 0) goto <D.25690>; else goto <D.25691>;
  <D.25690>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25696 = ctx->ip_offset;
    D.25697 = monoeg_g_strdup_printf ("Unmanaged pointer is not a verifiable type at 0x%04x", D.25696);
    vinfo->info.message = D.25697;
    vinfo->exception_type = 4;
    D.25698 = ctx->list;
    D.25699 = monoeg_g_slist_prepend (D.25698, vinfo);
    ctx->list = D.25699;
  }
  ctx->verifiable = 0;
  D.25694 = ctx->level;
  D.25700 = D.25694 & 16;
  if (D.25700 != 0) goto <D.25701>; else goto <D.25702>;
  <D.25701>:
  ctx->valid = 0;
  <D.25702>:
  <D.25691>:
  D.25703 = 0;
  return D.25703;
  <D.25689>:
  D.25703 = 1;
  return D.25703;
}


do_switch (struct VerifyContext * ctx, int count, const unsigned char * data)
{
  unsigned int D.25705;
  int D.25706;
  unsigned int D.25707;
  unsigned int D.25708;
  unsigned int D.25709;
  int D.25710;
  int D.25713;
  int D.25716;
  int D.25721;
  int D.25723;
  int D.25724;
  gchar * D.25725;
  struct GSList * D.25726;
  struct GSList * D.25727;
  int D.25728;
  int D.25731;
  sizetype D.25732;
  const unsigned char * D.25733;
  unsigned int D.25734;
  unsigned int base.92;
  unsigned int D.25736;
  int D.25740;
  gchar * D.25741;
  struct GSList * D.25742;
  struct MonoMethodHeader * D.25743;
  unsigned int target.93;
  int D.25745;
  gchar * D.25749;
  struct GSList * D.25750;
  gchar * D.25753;
  struct GSList * D.25754;
  struct ILCodeDesc * D.25756;
  struct ILCodeDesc * D.25757;
  unsigned int target.94;
  unsigned int D.25759;
  struct ILCodeDesc * D.25760;
  int i;
  int base;
  struct ILStackDesc * value;

  D.25705 = ctx->ip_offset;
  D.25706 = count * 4;
  D.25707 = (unsigned int) D.25706;
  D.25708 = D.25705 + D.25707;
  D.25709 = D.25708 + 5;
  base = (int) D.25709;
  D.25710 = check_underflow (ctx, 1);
  if (D.25710 == 0) goto <D.25711>; else goto <D.25712>;
  <D.25711>:
  return;
  <D.25712>:
  value = stack_pop (ctx);
  D.25713 = stack_slot_get_type (value);
  if (D.25713 != 1) goto <D.25714>; else goto <D.25715>;
  <D.25714>:
  D.25716 = stack_slot_get_type (value);
  if (D.25716 != 3) goto <D.25717>; else goto <D.25718>;
  <D.25717>:
  D.25721 = ctx->verifiable;
  if (D.25721 != 0) goto <D.25719>; else goto <D.25722>;
  <D.25722>:
  D.25723 = ctx->level;
  D.25724 = D.25723 & 128;
  if (D.25724 != 0) goto <D.25719>; else goto <D.25720>;
  <D.25719>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25705 = ctx->ip_offset;
    D.25725 = monoeg_g_strdup_printf ("Invalid argument to switch at 0x%04x", D.25705);
    vinfo->info.message = D.25725;
    vinfo->exception_type = 4;
    D.25726 = ctx->list;
    D.25727 = monoeg_g_slist_prepend (D.25726, vinfo);
    ctx->list = D.25727;
  }
  ctx->verifiable = 0;
  D.25723 = ctx->level;
  D.25728 = D.25723 & 16;
  if (D.25728 != 0) goto <D.25729>; else goto <D.25730>;
  <D.25729>:
  ctx->valid = 0;
  <D.25730>:
  <D.25720>:
  <D.25718>:
  <D.25715>:
  i = 0;
  goto <D.21453>;
  <D.21452>:
  {
    int target;

    D.25731 = i * 4;
    D.25732 = (sizetype) D.25731;
    D.25733 = data + D.25732;
    D.25734 = mono_read32 (D.25733);
    base.92 = (unsigned int) base;
    D.25736 = D.25734 + base.92;
    target = (int) D.25736;
    if (target < 0) goto <D.25737>; else goto <D.25739>;
    <D.25739>:
    D.25740 = ctx->code_size;
    if (D.25740 <= target) goto <D.25737>; else goto <D.25738>;
    <D.25737>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.25705 = ctx->ip_offset;
      D.25741 = monoeg_g_strdup_printf ("Switch target %x out of code at 0x%04x", i, D.25705);
      vinfo->info.message = D.25741;
      vinfo->exception_type = 3;
      D.25726 = ctx->list;
      D.25742 = monoeg_g_slist_prepend (D.25726, vinfo);
      ctx->list = D.25742;
    }
    ctx->valid = 0;
    return;
    <D.25738>:
    D.25743 = ctx->header;
    D.25705 = ctx->ip_offset;
    target.93 = (unsigned int) target;
    D.25745 = is_valid_branch_instruction (D.25743, D.25705, target.93);
    switch (D.25745) <default: <D.25755>, case 1: <D.21447>, case 2: <D.21450>>
    <D.21447>:
    D.25721 = ctx->verifiable;
    if (D.25721 != 0) goto <D.25746>; else goto <D.25748>;
    <D.25748>:
    D.25723 = ctx->level;
    D.25724 = D.25723 & 128;
    if (D.25724 != 0) goto <D.25746>; else goto <D.25747>;
    <D.25746>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 8;
      D.25705 = ctx->ip_offset;
      D.25749 = monoeg_g_strdup_printf ("Switch target %x escapes out of exception block at 0x%04x", i, D.25705);
      vinfo->info.message = D.25749;
      vinfo->exception_type = 4;
      D.25726 = ctx->list;
      D.25750 = monoeg_g_slist_prepend (D.25726, vinfo);
      ctx->list = D.25750;
    }
    ctx->verifiable = 0;
    D.25723 = ctx->level;
    D.25728 = D.25723 & 16;
    if (D.25728 != 0) goto <D.25751>; else goto <D.25752>;
    <D.25751>:
    ctx->valid = 0;
    <D.25752>:
    <D.25747>:
    goto <D.21449>;
    <D.21450>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.25705 = ctx->ip_offset;
      D.25753 = monoeg_g_strdup_printf ("Switch target %x escapes out of exception block at 0x%04x", i, D.25705);
      vinfo->info.message = D.25753;
      vinfo->exception_type = 3;
      D.25726 = ctx->list;
      D.25754 = monoeg_g_slist_prepend (D.25726, vinfo);
      ctx->list = D.25754;
    }
    ctx->valid = 0;
    return;
    <D.25755>:
    <D.21449>:
    D.25756 = &ctx->eval;
    D.25757 = ctx->code;
    target.94 = (unsigned int) target;
    D.25759 = target.94 * 12;
    D.25760 = D.25757 + D.25759;
    merge_stacks (ctx, D.25756, D.25760, 0, 1);
  }
  i = i + 1;
  <D.21453>:
  if (i < count) goto <D.21452>; else goto <D.21454>;
  <D.21454>:
}


do_load_indirect (struct VerifyContext * ctx, int opcode)
{
  unsigned int D.25762;
  unsigned int D.25763;
  int D.25764;
  int D.25767;
  int D.25772;
  int D.25774;
  int D.25775;
  unsigned int D.25776;
  gchar * D.25777;
  struct GSList * D.25778;
  struct GSList * D.25779;
  int D.25780;
  struct ILStackDesc * D.25783;
  struct MonoType * D.25784;
  int D.25789;
  struct MonoType * D.25791;
  struct MonoClass * D.25792;
  unsigned char D.25793;
  unsigned char D.25794;
  gchar * D.25798;
  struct GSList * D.25799;
  struct ILStackDesc * D.25802;
  struct MonoType * D.25803;
  struct MonoType * D.25805;
  struct MonoType * D.25806;
  int D.25807;
  gchar * D.25813;
  struct GSList * D.25814;
  struct ILStackDesc * D.25817;
  struct MonoType * D.25818;
  struct ILStackDesc * value;

  D.25762 = ctx->prefix_set;
  D.25763 = D.25762 & 4294967292;
  ctx->prefix_set = D.25763;
  D.25764 = check_underflow (ctx, 1);
  if (D.25764 == 0) goto <D.25765>; else goto <D.25766>;
  <D.25765>:
  return;
  <D.25766>:
  value = stack_pop (ctx);
  D.25767 = stack_slot_is_managed_pointer (value);
  if (D.25767 == 0) goto <D.25768>; else goto <D.25769>;
  <D.25768>:
  D.25772 = ctx->verifiable;
  if (D.25772 != 0) goto <D.25770>; else goto <D.25773>;
  <D.25773>:
  D.25774 = ctx->level;
  D.25775 = D.25774 & 128;
  if (D.25775 != 0) goto <D.25770>; else goto <D.25771>;
  <D.25770>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25776 = ctx->ip_offset;
    D.25777 = monoeg_g_strdup_printf ("Load indirect not using a manager pointer at 0x%04x", D.25776);
    vinfo->info.message = D.25777;
    vinfo->exception_type = 4;
    D.25778 = ctx->list;
    D.25779 = monoeg_g_slist_prepend (D.25778, vinfo);
    ctx->list = D.25779;
  }
  ctx->verifiable = 0;
  D.25774 = ctx->level;
  D.25780 = D.25774 & 16;
  if (D.25780 != 0) goto <D.25781>; else goto <D.25782>;
  <D.25781>:
  ctx->valid = 0;
  <D.25782>:
  <D.25771>:
  D.25783 = stack_push (ctx);
  D.25784 = mono_type_from_opcode (opcode);
  set_stack_value (ctx, D.25783, D.25784, 0);
  return;
  <D.25769>:
  if (opcode == 80) goto <D.25785>; else goto <D.25786>;
  <D.25785>:
  D.25789 = stack_slot_get_underlying_type (value);
  if (D.25789 != 6) goto <D.25787>; else goto <D.25790>;
  <D.25790>:
  D.25791 = value->type;
  D.25792 = mono_class_from_mono_type (D.25791);
  D.25793 = BIT_FIELD_REF <*D.25792, 8, 160>;
  D.25794 = D.25793 & 8;
  if (D.25794 != 0) goto <D.25787>; else goto <D.25788>;
  <D.25787>:
  D.25772 = ctx->verifiable;
  if (D.25772 != 0) goto <D.25795>; else goto <D.25797>;
  <D.25797>:
  D.25774 = ctx->level;
  D.25775 = D.25774 & 128;
  if (D.25775 != 0) goto <D.25795>; else goto <D.25796>;
  <D.25795>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25776 = ctx->ip_offset;
    D.25798 = monoeg_g_strdup_printf ("Invalid type at stack for ldind_ref expected object byref operation at 0x%04x", D.25776);
    vinfo->info.message = D.25798;
    vinfo->exception_type = 4;
    D.25778 = ctx->list;
    D.25799 = monoeg_g_slist_prepend (D.25778, vinfo);
    ctx->list = D.25799;
  }
  ctx->verifiable = 0;
  D.25774 = ctx->level;
  D.25780 = D.25774 & 16;
  if (D.25780 != 0) goto <D.25800>; else goto <D.25801>;
  <D.25800>:
  ctx->valid = 0;
  <D.25801>:
  <D.25796>:
  <D.25788>:
  D.25802 = stack_push (ctx);
  D.25791 = value->type;
  D.25803 = mono_type_get_type_byval (D.25791);
  set_stack_value (ctx, D.25802, D.25803, 0);
  goto <D.25804>;
  <D.25786>:
  D.25805 = mono_type_from_opcode (opcode);
  D.25791 = value->type;
  D.25806 = mono_type_get_type_byval (D.25791);
  D.25807 = verify_type_compatibility_full (ctx, D.25805, D.25806, 1);
  if (D.25807 == 0) goto <D.25808>; else goto <D.25809>;
  <D.25808>:
  D.25772 = ctx->verifiable;
  if (D.25772 != 0) goto <D.25810>; else goto <D.25812>;
  <D.25812>:
  D.25774 = ctx->level;
  D.25775 = D.25774 & 128;
  if (D.25775 != 0) goto <D.25810>; else goto <D.25811>;
  <D.25810>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25776 = ctx->ip_offset;
    D.25813 = monoeg_g_strdup_printf ("Invalid type at stack for ldind 0x%x operation at 0x%04x", opcode, D.25776);
    vinfo->info.message = D.25813;
    vinfo->exception_type = 4;
    D.25778 = ctx->list;
    D.25814 = monoeg_g_slist_prepend (D.25778, vinfo);
    ctx->list = D.25814;
  }
  ctx->verifiable = 0;
  D.25774 = ctx->level;
  D.25780 = D.25774 & 16;
  if (D.25780 != 0) goto <D.25815>; else goto <D.25816>;
  <D.25815>:
  ctx->valid = 0;
  <D.25816>:
  <D.25811>:
  <D.25809>:
  D.25817 = stack_push (ctx);
  D.25818 = mono_type_from_opcode (opcode);
  set_stack_value (ctx, D.25817, D.25818, 0);
  <D.25804>:
}


mono_type_from_opcode (int opcode)
{
  struct MonoType * D.25820;
  struct MonoClass * D.25821;
  struct MonoClass * D.25822;
  struct MonoClass * D.25823;
  struct MonoClass * D.25824;
  struct MonoClass * D.25825;
  struct MonoClass * D.25826;
  struct MonoClass * D.25827;
  struct MonoClass * D.25828;

  switch (opcode) <default: <D.21323>, case 70: <D.21285>, case 71: <D.21286>, case 72: <D.21291>, case 73: <D.21292>, case 74: <D.21297>, case 75: <D.21298>, case 76: <D.21303>, case 77: <D.21315>, case 78: <D.21307>, case 79: <D.21311>, case 80: <D.21319>, case 81: <D.21320>, case 82: <D.21287>, case 83: <D.21293>, case 84: <D.21299>, case 85: <D.21304>, case 86: <D.21308>, case 87: <D.21312>, case 144: <D.21288>, case 145: <D.21289>, case 146: <D.21294>, case 147: <D.21295>, case 148: <D.21300>, case 149: <D.21301>, case 150: <D.21305>, case 151: <D.21317>, case 152: <D.21309>, case 153: <D.21313>, case 154: <D.21321>, case 155: <D.21318>, case 156: <D.21290>, case 157: <D.21296>, case 158: <D.21302>, case 159: <D.21306>, case 160: <D.21310>, case 161: <D.21314>, case 162: <D.21322>, case 223: <D.21316>>
  <D.21285>:
  <D.21286>:
  <D.21287>:
  <D.21288>:
  <D.21289>:
  <D.21290>:
  D.25821 = mono_defaults.sbyte_class;
  D.25820 = &D.25821->byval_arg;
  return D.25820;
  <D.21291>:
  <D.21292>:
  <D.21293>:
  <D.21294>:
  <D.21295>:
  <D.21296>:
  D.25822 = mono_defaults.int16_class;
  D.25820 = &D.25822->byval_arg;
  return D.25820;
  <D.21297>:
  <D.21298>:
  <D.21299>:
  <D.21300>:
  <D.21301>:
  <D.21302>:
  D.25823 = mono_defaults.int32_class;
  D.25820 = &D.25823->byval_arg;
  return D.25820;
  <D.21303>:
  <D.21304>:
  <D.21305>:
  <D.21306>:
  D.25824 = mono_defaults.int64_class;
  D.25820 = &D.25824->byval_arg;
  return D.25820;
  <D.21307>:
  <D.21308>:
  <D.21309>:
  <D.21310>:
  D.25825 = mono_defaults.single_class;
  D.25820 = &D.25825->byval_arg;
  return D.25820;
  <D.21311>:
  <D.21312>:
  <D.21313>:
  <D.21314>:
  D.25826 = mono_defaults.double_class;
  D.25820 = &D.25826->byval_arg;
  return D.25820;
  <D.21315>:
  <D.21316>:
  <D.21317>:
  <D.21318>:
  D.25827 = mono_defaults.int_class;
  D.25820 = &D.25827->byval_arg;
  return D.25820;
  <D.21319>:
  <D.21320>:
  <D.21321>:
  <D.21322>:
  D.25828 = mono_defaults.object_class;
  D.25820 = &D.25828->byval_arg;
  return D.25820;
  <D.21323>:
  monoeg_g_log (0B, 4, "unknown opcode %02x in mono_type_from_opcode ", opcode);
  <D.21324>:
  goto <D.21324>;
  D.25820 = 0B;
  return D.25820;
}


do_store_indirect (struct VerifyContext * ctx, int opcode)
{
  unsigned int D.25830;
  unsigned int D.25831;
  int D.25832;
  int D.25835;
  int D.25838;
  int D.25843;
  int D.25845;
  int D.25846;
  unsigned int D.25847;
  gchar * D.25848;
  struct GSList * D.25849;
  struct GSList * D.25850;
  int D.25851;
  int D.25854;
  gchar * D.25860;
  struct GSList * D.25861;
  struct MonoType * D.25864;
  struct MonoType * D.25865;
  struct MonoType * D.25866;
  int D.25867;
  gchar * D.25873;
  struct GSList * D.25874;
  struct MonoType * D.25877;
  int D.25878;
  gchar * D.25884;
  struct GSList * D.25885;
  struct ILStackDesc * addr;
  struct ILStackDesc * val;

  D.25830 = ctx->prefix_set;
  D.25831 = D.25830 & 4294967292;
  ctx->prefix_set = D.25831;
  D.25832 = check_underflow (ctx, 2);
  if (D.25832 == 0) goto <D.25833>; else goto <D.25834>;
  <D.25833>:
  return;
  <D.25834>:
  val = stack_pop (ctx);
  addr = stack_pop (ctx);
  check_unmanaged_pointer (ctx, addr);
  D.25835 = stack_slot_is_managed_pointer (addr);
  if (D.25835 == 0) goto <D.25836>; else goto <D.25837>;
  <D.25836>:
  D.25838 = stack_slot_get_type (addr);
  if (D.25838 != 5) goto <D.25839>; else goto <D.25840>;
  <D.25839>:
  D.25843 = ctx->verifiable;
  if (D.25843 != 0) goto <D.25841>; else goto <D.25844>;
  <D.25844>:
  D.25845 = ctx->level;
  D.25846 = D.25845 & 128;
  if (D.25846 != 0) goto <D.25841>; else goto <D.25842>;
  <D.25841>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25847 = ctx->ip_offset;
    D.25848 = monoeg_g_strdup_printf ("Invalid non-pointer argument to stind at 0x%04x", D.25847);
    vinfo->info.message = D.25848;
    vinfo->exception_type = 4;
    D.25849 = ctx->list;
    D.25850 = monoeg_g_slist_prepend (D.25849, vinfo);
    ctx->list = D.25850;
  }
  ctx->verifiable = 0;
  D.25845 = ctx->level;
  D.25851 = D.25845 & 16;
  if (D.25851 != 0) goto <D.25852>; else goto <D.25853>;
  <D.25852>:
  ctx->valid = 0;
  <D.25853>:
  <D.25842>:
  return;
  <D.25840>:
  <D.25837>:
  D.25854 = stack_slot_is_managed_mutability_pointer (addr);
  if (D.25854 != 0) goto <D.25855>; else goto <D.25856>;
  <D.25855>:
  D.25843 = ctx->verifiable;
  if (D.25843 != 0) goto <D.25857>; else goto <D.25859>;
  <D.25859>:
  D.25845 = ctx->level;
  D.25846 = D.25845 & 128;
  if (D.25846 != 0) goto <D.25857>; else goto <D.25858>;
  <D.25857>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25847 = ctx->ip_offset;
    D.25860 = monoeg_g_strdup_printf ("Cannot use a readonly pointer with stind at 0x%04x", D.25847);
    vinfo->info.message = D.25860;
    vinfo->exception_type = 4;
    D.25849 = ctx->list;
    D.25861 = monoeg_g_slist_prepend (D.25849, vinfo);
    ctx->list = D.25861;
  }
  ctx->verifiable = 0;
  D.25845 = ctx->level;
  D.25851 = D.25845 & 16;
  if (D.25851 != 0) goto <D.25862>; else goto <D.25863>;
  <D.25862>:
  ctx->valid = 0;
  <D.25863>:
  <D.25858>:
  return;
  <D.25856>:
  D.25864 = mono_type_from_opcode (opcode);
  D.25865 = addr->type;
  D.25866 = mono_type_get_type_byval (D.25865);
  D.25867 = verify_type_compatibility_full (ctx, D.25864, D.25866, 1);
  if (D.25867 == 0) goto <D.25868>; else goto <D.25869>;
  <D.25868>:
  D.25843 = ctx->verifiable;
  if (D.25843 != 0) goto <D.25870>; else goto <D.25872>;
  <D.25872>:
  D.25845 = ctx->level;
  D.25846 = D.25845 & 128;
  if (D.25846 != 0) goto <D.25870>; else goto <D.25871>;
  <D.25870>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25847 = ctx->ip_offset;
    D.25873 = monoeg_g_strdup_printf ("Invalid addr type at stack for stind 0x%x operation at 0x%04x", opcode, D.25847);
    vinfo->info.message = D.25873;
    vinfo->exception_type = 4;
    D.25849 = ctx->list;
    D.25874 = monoeg_g_slist_prepend (D.25849, vinfo);
    ctx->list = D.25874;
  }
  ctx->verifiable = 0;
  D.25845 = ctx->level;
  D.25851 = D.25845 & 16;
  if (D.25851 != 0) goto <D.25875>; else goto <D.25876>;
  <D.25875>:
  ctx->valid = 0;
  <D.25876>:
  <D.25871>:
  <D.25869>:
  D.25877 = mono_type_from_opcode (opcode);
  D.25878 = verify_stack_type_compatibility (ctx, D.25877, val);
  if (D.25878 == 0) goto <D.25879>; else goto <D.25880>;
  <D.25879>:
  D.25843 = ctx->verifiable;
  if (D.25843 != 0) goto <D.25881>; else goto <D.25883>;
  <D.25883>:
  D.25845 = ctx->level;
  D.25846 = D.25845 & 128;
  if (D.25846 != 0) goto <D.25881>; else goto <D.25882>;
  <D.25881>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25847 = ctx->ip_offset;
    D.25884 = monoeg_g_strdup_printf ("Invalid value type at stack for stind 0x%x operation at 0x%04x", opcode, D.25847);
    vinfo->info.message = D.25884;
    vinfo->exception_type = 4;
    D.25849 = ctx->list;
    D.25885 = monoeg_g_slist_prepend (D.25849, vinfo);
    ctx->list = D.25885;
  }
  ctx->verifiable = 0;
  D.25845 = ctx->level;
  D.25851 = D.25845 & 16;
  if (D.25851 != 0) goto <D.25886>; else goto <D.25887>;
  <D.25886>:
  ctx->valid = 0;
  <D.25887>:
  <D.25882>:
  <D.25880>:
}


do_unary_math_op (struct VerifyContext * ctx, int op)
{
  int D.25889;
  int D.25892;
  struct MonoType * D.25894;
  int D.25895;
  int D.25899;
  int D.25901;
  int D.25902;
  unsigned int D.25903;
  gchar * D.25904;
  struct GSList * D.25905;
  struct GSList * D.25906;
  int D.25907;
  struct ILStackDesc * value;

  D.25889 = check_underflow (ctx, 1);
  if (D.25889 == 0) goto <D.25890>; else goto <D.25891>;
  <D.25890>:
  return;
  <D.25891>:
  value = stack_pop (ctx);
  D.25892 = stack_slot_get_type (value);
  switch (D.25892) <default: <D.21151>, case 1: <D.21145>, case 2: <D.21146>, case 3: <D.21147>, case 4: <D.21149>, case 6: <D.21150>>
  <D.21145>:
  <D.21146>:
  <D.21147>:
  goto <D.21148>;
  <D.21149>:
  if (op == 101) goto <D.21148>; else goto <D.25893>;
  <D.25893>:
  <D.21150>:
  D.25894 = value->type;
  D.25895 = mono_type_is_enum_type (D.25894);
  if (D.25895 != 0) goto <D.21148>; else goto <D.25896>;
  <D.25896>:
  <D.21151>:
  D.25899 = ctx->verifiable;
  if (D.25899 != 0) goto <D.25897>; else goto <D.25900>;
  <D.25900>:
  D.25901 = ctx->level;
  D.25902 = D.25901 & 128;
  if (D.25902 != 0) goto <D.25897>; else goto <D.25898>;
  <D.25897>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25903 = ctx->ip_offset;
    D.25904 = monoeg_g_strdup_printf ("Invalid type at stack for unary not at 0x%04x", D.25903);
    vinfo->info.message = D.25904;
    vinfo->exception_type = 4;
    D.25905 = ctx->list;
    D.25906 = monoeg_g_slist_prepend (D.25905, vinfo);
    ctx->list = D.25906;
  }
  ctx->verifiable = 0;
  D.25901 = ctx->level;
  D.25907 = D.25901 & 16;
  if (D.25907 != 0) goto <D.25908>; else goto <D.25909>;
  <D.25908>:
  ctx->valid = 0;
  <D.25909>:
  <D.25898>:
  <D.21148>:
  stack_push_stack_val (ctx, value);
}


stack_push_stack_val (struct VerifyContext * ctx, struct ILStackDesc * value)
{
  struct ILStackDesc * D.25912;
  struct ILStackDesc * top;

  top = stack_push (ctx);
  copy_stack_value (top, value);
  D.25912 = top;
  return D.25912;
}


do_cpobj (struct VerifyContext * ctx, int token)
{
  int D.25916;
  int D.25919;
  int D.25924;
  int D.25926;
  int D.25927;
  unsigned int D.25928;
  gchar * D.25929;
  struct GSList * D.25930;
  struct GSList * D.25931;
  int D.25932;
  int D.25935;
  gchar * D.25941;
  struct GSList * D.25942;
  int D.25945;
  gchar * D.25951;
  struct GSList * D.25952;
  struct MonoType * D.25955;
  struct MonoType * D.25956;
  int D.25957;
  gchar * D.25963;
  struct GSList * D.25964;
  struct MonoType * D.25967;
  struct MonoType * D.25968;
  int D.25969;
  gchar * D.25975;
  struct GSList * D.25976;
  struct ILStackDesc * dest;
  struct ILStackDesc * src;
  struct MonoType * type;

  type = get_boxable_mono_type (ctx, token, "cpobj");
  if (type == 0B) goto <D.25914>; else goto <D.25915>;
  <D.25914>:
  return;
  <D.25915>:
  D.25916 = check_underflow (ctx, 2);
  if (D.25916 == 0) goto <D.25917>; else goto <D.25918>;
  <D.25917>:
  return;
  <D.25918>:
  src = stack_pop (ctx);
  dest = stack_pop (ctx);
  D.25919 = stack_slot_is_managed_pointer (src);
  if (D.25919 == 0) goto <D.25920>; else goto <D.25921>;
  <D.25920>:
  D.25924 = ctx->verifiable;
  if (D.25924 != 0) goto <D.25922>; else goto <D.25925>;
  <D.25925>:
  D.25926 = ctx->level;
  D.25927 = D.25926 & 128;
  if (D.25927 != 0) goto <D.25922>; else goto <D.25923>;
  <D.25922>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25928 = ctx->ip_offset;
    D.25929 = monoeg_g_strdup_printf ("Invalid source of cpobj operation at 0x%04x", D.25928);
    vinfo->info.message = D.25929;
    vinfo->exception_type = 4;
    D.25930 = ctx->list;
    D.25931 = monoeg_g_slist_prepend (D.25930, vinfo);
    ctx->list = D.25931;
  }
  ctx->verifiable = 0;
  D.25926 = ctx->level;
  D.25932 = D.25926 & 16;
  if (D.25932 != 0) goto <D.25933>; else goto <D.25934>;
  <D.25933>:
  ctx->valid = 0;
  <D.25934>:
  <D.25923>:
  <D.25921>:
  D.25935 = stack_slot_is_managed_pointer (dest);
  if (D.25935 == 0) goto <D.25936>; else goto <D.25937>;
  <D.25936>:
  D.25924 = ctx->verifiable;
  if (D.25924 != 0) goto <D.25938>; else goto <D.25940>;
  <D.25940>:
  D.25926 = ctx->level;
  D.25927 = D.25926 & 128;
  if (D.25927 != 0) goto <D.25938>; else goto <D.25939>;
  <D.25938>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25928 = ctx->ip_offset;
    D.25941 = monoeg_g_strdup_printf ("Invalid destination of cpobj operation at 0x%04x", D.25928);
    vinfo->info.message = D.25941;
    vinfo->exception_type = 4;
    D.25930 = ctx->list;
    D.25942 = monoeg_g_slist_prepend (D.25930, vinfo);
    ctx->list = D.25942;
  }
  ctx->verifiable = 0;
  D.25926 = ctx->level;
  D.25932 = D.25926 & 16;
  if (D.25932 != 0) goto <D.25943>; else goto <D.25944>;
  <D.25943>:
  ctx->valid = 0;
  <D.25944>:
  <D.25939>:
  <D.25937>:
  D.25945 = stack_slot_is_managed_mutability_pointer (dest);
  if (D.25945 != 0) goto <D.25946>; else goto <D.25947>;
  <D.25946>:
  D.25924 = ctx->verifiable;
  if (D.25924 != 0) goto <D.25948>; else goto <D.25950>;
  <D.25950>:
  D.25926 = ctx->level;
  D.25927 = D.25926 & 128;
  if (D.25927 != 0) goto <D.25948>; else goto <D.25949>;
  <D.25948>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25928 = ctx->ip_offset;
    D.25951 = monoeg_g_strdup_printf ("Cannot use a readonly pointer with cpobj at 0x%04x", D.25928);
    vinfo->info.message = D.25951;
    vinfo->exception_type = 4;
    D.25930 = ctx->list;
    D.25952 = monoeg_g_slist_prepend (D.25930, vinfo);
    ctx->list = D.25952;
  }
  ctx->verifiable = 0;
  D.25926 = ctx->level;
  D.25932 = D.25926 & 16;
  if (D.25932 != 0) goto <D.25953>; else goto <D.25954>;
  <D.25953>:
  ctx->valid = 0;
  <D.25954>:
  <D.25949>:
  <D.25947>:
  D.25955 = src->type;
  D.25956 = mono_type_get_type_byval (D.25955);
  D.25957 = verify_type_compatibility (ctx, type, D.25956);
  if (D.25957 == 0) goto <D.25958>; else goto <D.25959>;
  <D.25958>:
  D.25924 = ctx->verifiable;
  if (D.25924 != 0) goto <D.25960>; else goto <D.25962>;
  <D.25962>:
  D.25926 = ctx->level;
  D.25927 = D.25926 & 128;
  if (D.25927 != 0) goto <D.25960>; else goto <D.25961>;
  <D.25960>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25928 = ctx->ip_offset;
    D.25963 = monoeg_g_strdup_printf ("Token and source types of cpobj don\'t match at 0x%04x", D.25928);
    vinfo->info.message = D.25963;
    vinfo->exception_type = 4;
    D.25930 = ctx->list;
    D.25964 = monoeg_g_slist_prepend (D.25930, vinfo);
    ctx->list = D.25964;
  }
  ctx->verifiable = 0;
  D.25926 = ctx->level;
  D.25932 = D.25926 & 16;
  if (D.25932 != 0) goto <D.25965>; else goto <D.25966>;
  <D.25965>:
  ctx->valid = 0;
  <D.25966>:
  <D.25961>:
  <D.25959>:
  D.25967 = dest->type;
  D.25968 = mono_type_get_type_byval (D.25967);
  D.25969 = verify_type_compatibility (ctx, D.25968, type);
  if (D.25969 == 0) goto <D.25970>; else goto <D.25971>;
  <D.25970>:
  D.25924 = ctx->verifiable;
  if (D.25924 != 0) goto <D.25972>; else goto <D.25974>;
  <D.25974>:
  D.25926 = ctx->level;
  D.25927 = D.25926 & 128;
  if (D.25927 != 0) goto <D.25972>; else goto <D.25973>;
  <D.25972>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.25928 = ctx->ip_offset;
    D.25975 = monoeg_g_strdup_printf ("Destination and token types of cpobj don\'t match at 0x%04x", D.25928);
    vinfo->info.message = D.25975;
    vinfo->exception_type = 4;
    D.25930 = ctx->list;
    D.25976 = monoeg_g_slist_prepend (D.25930, vinfo);
    ctx->list = D.25976;
  }
  ctx->verifiable = 0;
  D.25926 = ctx->level;
  D.25932 = D.25926 & 16;
  if (D.25932 != 0) goto <D.25977>; else goto <D.25978>;
  <D.25977>:
  ctx->valid = 0;
  <D.25978>:
  <D.25973>:
  <D.25971>:
}


verify_type_compatibility (struct VerifyContext * ctx, struct MonoType * target, struct MonoType * candidate)
{
  gboolean D.25980;

  D.25980 = verify_type_compatibility_full (ctx, target, candidate, 0);
  return D.25980;
}


do_ldobj_value (struct VerifyContext * ctx, int token)
{
  unsigned int D.25982;
  unsigned int D.25983;
  int D.25986;
  int D.25991;
  int D.25994;
  int D.25997;
  struct MonoType * D.25999;
  unsigned char D.26000;
  const char * D.26001;
  unsigned int D.26002;
  gchar * D.26003;
  struct GSList * D.26004;
  struct GSList * D.26005;
  int D.26006;
  int D.26011;
  int D.26013;
  int D.26014;
  gchar * D.26015;
  struct GSList * D.26016;
  int D.26017;
  struct MonoType * D.26020;
  int D.26021;
  gchar * D.26027;
  struct GSList * D.26028;
  struct ILStackDesc * D.26031;
  struct ILStackDesc * value;
  struct MonoType * type;

  type = get_boxable_mono_type (ctx, token, "ldobj");
  D.25982 = ctx->prefix_set;
  D.25983 = D.25982 & 4294967292;
  ctx->prefix_set = D.25983;
  if (type == 0B) goto <D.25984>; else goto <D.25985>;
  <D.25984>:
  return;
  <D.25985>:
  D.25986 = check_underflow (ctx, 1);
  if (D.25986 == 0) goto <D.25987>; else goto <D.25988>;
  <D.25987>:
  return;
  <D.25988>:
  value = stack_pop (ctx);
  D.25991 = stack_slot_is_managed_pointer (value);
  if (D.25991 == 0) goto <D.25992>; else goto <D.25993>;
  <D.25992>:
  D.25994 = stack_slot_get_type (value);
  if (D.25994 != 3) goto <D.25995>; else goto <D.25996>;
  <D.25995>:
  D.25997 = stack_slot_get_type (value);
  if (D.25997 != 5) goto <D.25989>; else goto <D.25998>;
  <D.25998>:
  D.25999 = value->type;
  D.26000 = D.25999->type;
  if (D.26000 == 27) goto <D.25989>; else goto <D.25990>;
  <D.25989>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.26001 = stack_slot_get_name (value);
    D.26002 = ctx->ip_offset;
    D.26003 = monoeg_g_strdup_printf ("Invalid argument %s to ldobj at 0x%04x", D.26001, D.26002);
    vinfo->info.message = D.26003;
    vinfo->exception_type = 3;
    D.26004 = ctx->list;
    D.26005 = monoeg_g_slist_prepend (D.26004, vinfo);
    ctx->list = D.26005;
  }
  ctx->valid = 0;
  return;
  <D.25990>:
  <D.25996>:
  <D.25993>:
  D.26006 = stack_slot_get_type (value);
  if (D.26006 == 3) goto <D.26007>; else goto <D.26008>;
  <D.26007>:
  D.26011 = ctx->verifiable;
  if (D.26011 != 0) goto <D.26009>; else goto <D.26012>;
  <D.26012>:
  D.26013 = ctx->level;
  D.26014 = D.26013 & 128;
  if (D.26014 != 0) goto <D.26009>; else goto <D.26010>;
  <D.26009>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26002 = ctx->ip_offset;
    D.26015 = monoeg_g_strdup_printf ("Using native pointer to ldobj at 0x%04x", D.26002);
    vinfo->info.message = D.26015;
    vinfo->exception_type = 4;
    D.26004 = ctx->list;
    D.26016 = monoeg_g_slist_prepend (D.26004, vinfo);
    ctx->list = D.26016;
  }
  ctx->verifiable = 0;
  D.26013 = ctx->level;
  D.26017 = D.26013 & 16;
  if (D.26017 != 0) goto <D.26018>; else goto <D.26019>;
  <D.26018>:
  ctx->valid = 0;
  <D.26019>:
  <D.26010>:
  <D.26008>:
  D.25999 = value->type;
  D.26020 = mono_type_get_type_byval (D.25999);
  D.26021 = verify_type_compatibility_full (ctx, type, D.26020, 1);
  if (D.26021 == 0) goto <D.26022>; else goto <D.26023>;
  <D.26022>:
  D.26011 = ctx->verifiable;
  if (D.26011 != 0) goto <D.26024>; else goto <D.26026>;
  <D.26026>:
  D.26013 = ctx->level;
  D.26014 = D.26013 & 128;
  if (D.26014 != 0) goto <D.26024>; else goto <D.26025>;
  <D.26024>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26002 = ctx->ip_offset;
    D.26027 = monoeg_g_strdup_printf ("Invalid type at stack for ldojb operation at 0x%04x", D.26002);
    vinfo->info.message = D.26027;
    vinfo->exception_type = 4;
    D.26004 = ctx->list;
    D.26028 = monoeg_g_slist_prepend (D.26004, vinfo);
    ctx->list = D.26028;
  }
  ctx->verifiable = 0;
  D.26013 = ctx->level;
  D.26017 = D.26013 & 16;
  if (D.26017 != 0) goto <D.26029>; else goto <D.26030>;
  <D.26029>:
  ctx->valid = 0;
  <D.26030>:
  <D.26025>:
  <D.26023>:
  D.26031 = stack_push (ctx);
  set_stack_value (ctx, D.26031, type, 0);
}


do_ldstr (struct VerifyContext * ctx, guint32 token)
{
  struct MonoMethod * D.26033;
  unsigned char D.26034;
  unsigned char D.26035;
  struct MonoImage * D.26038;
  unsigned char D.26039;
  unsigned char D.26040;
  unsigned int D.26043;
  unsigned int D.26046;
  gchar * D.26047;
  struct GSList * D.26048;
  struct GSList * D.26049;
  unsigned int D.26050;
  int D.26051;
  struct GSList * error.95;
  struct GSList * D.26057;
  gchar * D.26058;
  struct GSList * D.26059;
  int D.26060;
  struct MonoClass * D.26063;
  struct MonoType * D.26064;
  struct GSList * error;

  try
    {
      error = 0B;
      D.26033 = ctx->method;
      D.26034 = BIT_FIELD_REF <*D.26033, 8, 160>;
      D.26035 = D.26034 & 124;
      if (D.26035 == 0) goto <D.26036>; else goto <D.26037>;
      <D.26036>:
      D.26038 = ctx->image;
      D.26039 = BIT_FIELD_REF <*D.26038, 8, 128>;
      D.26040 = D.26039 & 8;
      if (D.26040 == 0) goto <D.26041>; else goto <D.26042>;
      <D.26041>:
      D.26043 = token & 4278190080;
      if (D.26043 != 1879048192) goto <D.26044>; else goto <D.26045>;
      <D.26044>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26046 = ctx->ip_offset;
        D.26047 = monoeg_g_strdup_printf ("Invalid string token %x at 0x%04x", token, D.26046);
        vinfo->info.message = D.26047;
        vinfo->exception_type = 12;
        D.26048 = ctx->list;
        D.26049 = monoeg_g_slist_prepend (D.26048, vinfo);
        ctx->list = D.26049;
      }
      ctx->valid = 0;
      return;
      <D.26045>:
      D.26038 = ctx->image;
      D.26050 = token & 16777215;
      D.26051 = mono_verifier_verify_string_signature (D.26038, D.26050, &error);
      if (D.26051 == 0) goto <D.26052>; else goto <D.26053>;
      <D.26052>:
      error.95 = error;
      if (error.95 != 0B) goto <D.26055>; else goto <D.26056>;
      <D.26055>:
      D.26048 = ctx->list;
      error.95 = error;
      D.26057 = monoeg_g_slist_concat (D.26048, error.95);
      ctx->list = D.26057;
      <D.26056>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26046 = ctx->ip_offset;
        D.26058 = monoeg_g_strdup_printf ("Invalid string index %x at 0x%04x", token, D.26046);
        vinfo->info.message = D.26058;
        vinfo->exception_type = 12;
        D.26048 = ctx->list;
        D.26059 = monoeg_g_slist_prepend (D.26048, vinfo);
        ctx->list = D.26059;
      }
      ctx->valid = 0;
      return;
      <D.26053>:
      <D.26042>:
      <D.26037>:
      D.26060 = check_overflow (ctx);
      if (D.26060 != 0) goto <D.26061>; else goto <D.26062>;
      <D.26061>:
      D.26063 = mono_defaults.string_class;
      D.26064 = &D.26063->byval_arg;
      stack_push_val (ctx, 6, D.26064);
      <D.26062>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


do_newobj (struct VerifyContext * ctx, int token)
{
  int D.26070;
  unsigned int D.26073;
  gchar * D.26074;
  struct GSList * D.26075;
  struct GSList * D.26076;
  struct MonoClass * D.26077;
  unsigned int D.26078;
  unsigned int D.26079;
  int D.26084;
  int D.26086;
  int D.26087;
  gchar * D.26088;
  struct GSList * D.26089;
  int D.26090;
  int D.26093;
  struct MonoMethod * D.26096;
  int D.26097;
  gchar * D.26103;
  struct GSList * D.26104;
  gchar * D.26109;
  struct GSList * D.26110;
  unsigned char D.26111;
  unsigned char D.26112;
  gchar * D.26115;
  struct GSList * D.26116;
  short unsigned int D.26117;
  int D.26118;
  int D.26119;
  struct MonoClass * D.26122;
  struct MonoClass * D.26123;
  _Bool D.26124;
  gchar * D.26129;
  struct GSList * D.26130;
  struct MonoType * D.26132;
  int D.26133;
  gchar * D.26139;
  struct GSList * D.26140;
  int D.26143;
  gchar * D.26149;
  struct GSList * D.26150;
  int D.26153;
  struct ILStackDesc * D.26156;
  struct MonoType * D.26157;
  struct ILStackDesc * value;
  int i;
  struct MonoMethodSignature * sig;
  struct MonoMethod * method;
  gboolean is_delegate;

  is_delegate = 0;
  method = verifier_load_method (ctx, token, "newobj");
  if (method == 0B) goto <D.26068>; else goto <D.26069>;
  <D.26068>:
  return;
  <D.26069>:
  D.26070 = mono_method_is_constructor (method);
  if (D.26070 == 0) goto <D.26071>; else goto <D.26072>;
  <D.26071>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.26073 = ctx->ip_offset;
    D.26074 = monoeg_g_strdup_printf ("Method from token 0x%08x not a constructor at 0x%04x", token, D.26073);
    vinfo->info.message = D.26074;
    vinfo->exception_type = 3;
    D.26075 = ctx->list;
    D.26076 = monoeg_g_slist_prepend (D.26075, vinfo);
    ctx->list = D.26076;
  }
  ctx->valid = 0;
  return;
  <D.26072>:
  D.26077 = method->klass;
  D.26078 = D.26077->flags;
  D.26079 = D.26078 & 160;
  if (D.26079 != 0) goto <D.26080>; else goto <D.26081>;
  <D.26080>:
  D.26084 = ctx->verifiable;
  if (D.26084 != 0) goto <D.26082>; else goto <D.26085>;
  <D.26085>:
  D.26086 = ctx->level;
  D.26087 = D.26086 & 128;
  if (D.26087 != 0) goto <D.26082>; else goto <D.26083>;
  <D.26082>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26073 = ctx->ip_offset;
    D.26088 = monoeg_g_strdup_printf ("Trying to instantiate an abstract or interface type at 0x%04x", D.26073);
    vinfo->info.message = D.26088;
    vinfo->exception_type = 4;
    D.26075 = ctx->list;
    D.26089 = monoeg_g_slist_prepend (D.26075, vinfo);
    ctx->list = D.26089;
  }
  ctx->verifiable = 0;
  D.26086 = ctx->level;
  D.26090 = D.26086 & 16;
  if (D.26090 != 0) goto <D.26091>; else goto <D.26092>;
  <D.26091>:
  ctx->valid = 0;
  <D.26092>:
  <D.26083>:
  <D.26081>:
  D.26086 = ctx->level;
  D.26093 = D.26086 & 64;
  if (D.26093 == 0) goto <D.26094>; else goto <D.26095>;
  <D.26094>:
  D.26096 = ctx->method;
  D.26097 = mono_method_can_access_method_full (D.26096, method, 0B);
  if (D.26097 == 0) goto <D.26098>; else goto <D.26099>;
  <D.26098>:
  {
    char * from;
    char * to;

    D.26096 = ctx->method;
    from = mono_method_full_name (D.26096, 1);
    to = mono_method_full_name (method, 1);
    D.26084 = ctx->verifiable;
    if (D.26084 != 0) goto <D.26100>; else goto <D.26102>;
    <D.26102>:
    D.26086 = ctx->level;
    D.26087 = D.26086 & 128;
    if (D.26087 != 0) goto <D.26100>; else goto <D.26101>;
    <D.26100>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 8;
      D.26073 = ctx->ip_offset;
      D.26103 = monoeg_g_strdup_printf ("Constructor %s not visible from %s at 0x%04x", to, from, D.26073);
      vinfo->info.message = D.26103;
      vinfo->exception_type = 9;
      D.26075 = ctx->list;
      D.26104 = monoeg_g_slist_prepend (D.26075, vinfo);
      ctx->list = D.26104;
    }
    ctx->verifiable = 0;
    D.26086 = ctx->level;
    D.26090 = D.26086 & 16;
    if (D.26090 != 0) goto <D.26105>; else goto <D.26106>;
    <D.26105>:
    ctx->valid = 0;
    <D.26106>:
    <D.26101>:
    monoeg_g_free (from);
    monoeg_g_free (to);
  }
  <D.26099>:
  <D.26095>:
  sig = mono_method_signature (method);
  if (sig == 0B) goto <D.26107>; else goto <D.26108>;
  <D.26107>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.26073 = ctx->ip_offset;
    D.26109 = monoeg_g_strdup_printf ("Invalid constructor signature to newobj at 0x%04x", D.26073);
    vinfo->info.message = D.26109;
    vinfo->exception_type = 3;
    D.26075 = ctx->list;
    D.26110 = monoeg_g_slist_prepend (D.26075, vinfo);
    ctx->list = D.26110;
  }
  ctx->valid = 0;
  return;
  <D.26108>:
  D.26111 = BIT_FIELD_REF <*sig, 8, 80>;
  D.26112 = D.26111 & 64;
  if (D.26112 == 0) goto <D.26113>; else goto <D.26114>;
  <D.26113>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.26073 = ctx->ip_offset;
    D.26115 = monoeg_g_strdup_printf ("Invalid constructor signature missing hasthis at 0x%04x", D.26073);
    vinfo->info.message = D.26115;
    vinfo->exception_type = 3;
    D.26075 = ctx->list;
    D.26116 = monoeg_g_slist_prepend (D.26075, vinfo);
    ctx->list = D.26116;
  }
  ctx->valid = 0;
  return;
  <D.26114>:
  D.26117 = sig->param_count;
  D.26118 = (int) D.26117;
  D.26119 = check_underflow (ctx, D.26118);
  if (D.26119 == 0) goto <D.26120>; else goto <D.26121>;
  <D.26120>:
  return;
  <D.26121>:
  D.26077 = method->klass;
  D.26122 = D.26077->parent;
  D.26123 = mono_defaults.multicastdelegate_class;
  D.26124 = D.26122 == D.26123;
  is_delegate = (gboolean) D.26124;
  if (is_delegate != 0) goto <D.26125>; else goto <D.26126>;
  <D.26125>:
  {
    struct ILStackDesc * funptr;

    D.26117 = sig->param_count;
    if (D.26117 != 2) goto <D.26127>; else goto <D.26128>;
    <D.26127>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.26073 = ctx->ip_offset;
      D.26129 = monoeg_g_strdup_printf ("Invalid delegate constructor at 0x%04x", D.26073);
      vinfo->info.message = D.26129;
      vinfo->exception_type = 3;
      D.26075 = ctx->list;
      D.26130 = monoeg_g_slist_prepend (D.26075, vinfo);
      ctx->list = D.26130;
    }
    ctx->valid = 0;
    return;
    <D.26128>:
    funptr = stack_pop (ctx);
    value = stack_pop (ctx);
    D.26077 = method->klass;
    verify_delegate_compatibility (ctx, D.26077, value, funptr);
  }
  goto <D.26131>;
  <D.26126>:
  D.26117 = sig->param_count;
  D.26118 = (int) D.26117;
  i = D.26118 + -1;
  goto <D.21263>;
  <D.21262>:
  value = stack_pop (ctx);
  D.26132 = sig->params[i];
  D.26133 = verify_stack_type_compatibility (ctx, D.26132, value);
  if (D.26133 == 0) goto <D.26134>; else goto <D.26135>;
  <D.26134>:
  {
    char * stack_name;
    char * sig_name;

    stack_name = stack_slot_full_name (value);
    D.26132 = sig->params[i];
    sig_name = mono_type_full_name (D.26132);
    D.26084 = ctx->verifiable;
    if (D.26084 != 0) goto <D.26136>; else goto <D.26138>;
    <D.26138>:
    D.26086 = ctx->level;
    D.26087 = D.26086 & 128;
    if (D.26087 != 0) goto <D.26136>; else goto <D.26137>;
    <D.26136>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 8;
      D.26073 = ctx->ip_offset;
      D.26139 = monoeg_g_strdup_printf ("Incompatible parameter value with constructor signature: %s X %s at 0x%04x", sig_name, stack_name, D.26073);
      vinfo->info.message = D.26139;
      vinfo->exception_type = 4;
      D.26075 = ctx->list;
      D.26140 = monoeg_g_slist_prepend (D.26075, vinfo);
      ctx->list = D.26140;
    }
    ctx->verifiable = 0;
    D.26086 = ctx->level;
    D.26090 = D.26086 & 16;
    if (D.26090 != 0) goto <D.26141>; else goto <D.26142>;
    <D.26141>:
    ctx->valid = 0;
    <D.26142>:
    <D.26137>:
    monoeg_g_free (stack_name);
    monoeg_g_free (sig_name);
  }
  <D.26135>:
  D.26143 = stack_slot_is_managed_mutability_pointer (value);
  if (D.26143 != 0) goto <D.26144>; else goto <D.26145>;
  <D.26144>:
  D.26084 = ctx->verifiable;
  if (D.26084 != 0) goto <D.26146>; else goto <D.26148>;
  <D.26148>:
  D.26086 = ctx->level;
  D.26087 = D.26086 & 128;
  if (D.26087 != 0) goto <D.26146>; else goto <D.26147>;
  <D.26146>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26073 = ctx->ip_offset;
    D.26149 = monoeg_g_strdup_printf ("Cannot use a readonly pointer as argument of newobj at 0x%04x", D.26073);
    vinfo->info.message = D.26149;
    vinfo->exception_type = 4;
    D.26075 = ctx->list;
    D.26150 = monoeg_g_slist_prepend (D.26075, vinfo);
    ctx->list = D.26150;
  }
  ctx->verifiable = 0;
  D.26086 = ctx->level;
  D.26090 = D.26086 & 16;
  if (D.26090 != 0) goto <D.26151>; else goto <D.26152>;
  <D.26151>:
  ctx->valid = 0;
  <D.26152>:
  <D.26147>:
  <D.26145>:
  i = i + -1;
  <D.21263>:
  if (i >= 0) goto <D.21262>; else goto <D.21264>;
  <D.21264>:
  <D.26131>:
  D.26153 = check_overflow (ctx);
  if (D.26153 != 0) goto <D.26154>; else goto <D.26155>;
  <D.26154>:
  D.26156 = stack_push (ctx);
  D.26077 = method->klass;
  D.26157 = &D.26077->byval_arg;
  set_stack_value (ctx, D.26156, D.26157, 0);
  <D.26155>:
}


verify_delegate_compatibility (struct VerifyContext * ctx, struct MonoClass * delegate, struct ILStackDesc * value, struct ILStackDesc * funptr)
{
  struct MonoMethodHeader * D.26159;
  int D.26162;
  struct MonoMethod * D.26164;
  int D.26167;
  int D.26169;
  int D.26170;
  unsigned int D.26171;
  gchar * D.26172;
  struct GSList * D.26173;
  struct GSList * D.26174;
  int D.26175;
  struct MonoMethodSignature * D.26181;
  gchar * D.26182;
  struct GSList * D.26183;
  struct MonoMethodSignature * D.26187;
  gchar * D.26188;
  struct GSList * D.26189;
  int iftmp.96;
  sizetype D.26194;
  const guint8 * D.26195;
  unsigned char D.26196;
  struct ILCodeDesc * D.26198;
  unsigned int D.26199;
  sizetype D.26200;
  struct ILCodeDesc * D.26201;
  short unsigned int D.26202;
  int D.26203;
  int D.26204;
  sizetype D.26206;
  const guint8 * D.26207;
  unsigned char D.26208;
  short unsigned int D.26210;
  int D.26211;
  int D.26212;
  struct MonoMethodSignature * D.26216;
  short unsigned int D.26217;
  int D.26218;
  int D.26219;
  struct MonoMethodSignature * D.26220;
  short unsigned int D.26221;
  int D.26222;
  _Bool D.26223;
  struct MonoMethodSignature * D.26224;
  struct MonoMethodSignature * D.26225;
  int D.26226;
  struct MonoMethodSignature * D.26229;
  struct MonoMethodSignature * D.26230;
  gchar * D.26234;
  struct GSList * D.26235;
  sizetype D.26247;
  const guint8 * D.26248;
  unsigned char D.26249;
  sizetype D.26251;
  struct ILCodeDesc * D.26252;
  short unsigned int D.26253;
  int D.26254;
  int D.26255;
  short unsigned int D.26260;
  gchar * D.26264;
  struct GSList * D.26265;
  struct ILCodeDesc * D.26268;
  short unsigned int D.26269;
  short unsigned int D.26270;
  struct MonoMethodSignature * D.26275;
  short unsigned int D.26276;
  struct MonoMethodSignature * D.26278;
  struct MonoType * D.26279;
  int D.26280;
  gchar * D.26284;
  struct GSList * D.26285;
  int D.26291;
  gchar * D.26299;
  struct GSList * D.26300;
  struct MonoClass * D.26304;
  struct MonoType * D.26305;
  int D.26306;
  int D.26309;
  gchar * D.26315;
  struct GSList * D.26316;
  int D.26319;
  gchar * D.26325;
  struct GSList * D.26326;
  struct MonoMethod * invoke;
  struct MonoMethod * method;
  const guint8 * ip;
  guint32 ip_offset;
  gboolean is_static_ldftn;
  gboolean is_first_arg_bound;

  D.26159 = ctx->header;
  ip = D.26159->code;
  ip_offset = ctx->ip_offset;
  is_static_ldftn = 0;
  is_first_arg_bound = 0;
  D.26162 = stack_slot_get_type (funptr);
  if (D.26162 != 5) goto <D.26160>; else goto <D.26163>;
  <D.26163>:
  D.26164 = funptr->method;
  if (D.26164 == 0B) goto <D.26160>; else goto <D.26161>;
  <D.26160>:
  D.26167 = ctx->verifiable;
  if (D.26167 != 0) goto <D.26165>; else goto <D.26168>;
  <D.26168>:
  D.26169 = ctx->level;
  D.26170 = D.26169 & 128;
  if (D.26170 != 0) goto <D.26165>; else goto <D.26166>;
  <D.26165>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26171 = ctx->ip_offset;
    D.26172 = monoeg_g_strdup_printf ("Invalid function pointer parameter for delegate constructor at 0x%04x", D.26171);
    vinfo->info.message = D.26172;
    vinfo->exception_type = 4;
    D.26173 = ctx->list;
    D.26174 = monoeg_g_slist_prepend (D.26173, vinfo);
    ctx->list = D.26174;
  }
  ctx->verifiable = 0;
  D.26169 = ctx->level;
  D.26175 = D.26169 & 16;
  if (D.26175 != 0) goto <D.26176>; else goto <D.26177>;
  <D.26176>:
  ctx->valid = 0;
  <D.26177>:
  <D.26166>:
  return;
  <D.26161>:
  invoke = mono_get_delegate_invoke (delegate);
  method = funptr->method;
  if (method == 0B) goto <D.26178>; else goto <D.26180>;
  <D.26180>:
  D.26181 = mono_method_signature (method);
  if (D.26181 == 0B) goto <D.26178>; else goto <D.26179>;
  <D.26178>:
  {
    char * name;

    name = mono_type_get_full_name (delegate);
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.26171 = ctx->ip_offset;
      D.26182 = monoeg_g_strdup_printf ("Invalid method on stack to create delegate %s construction at 0x%04x", name, D.26171);
      vinfo->info.message = D.26182;
      vinfo->exception_type = 3;
      D.26173 = ctx->list;
      D.26183 = monoeg_g_slist_prepend (D.26173, vinfo);
      ctx->list = D.26183;
    }
    ctx->valid = 0;
    monoeg_g_free (name);
    return;
  }
  <D.26179>:
  if (invoke == 0B) goto <D.26184>; else goto <D.26186>;
  <D.26186>:
  D.26187 = mono_method_signature (invoke);
  if (D.26187 == 0B) goto <D.26184>; else goto <D.26185>;
  <D.26184>:
  {
    char * name;

    name = mono_type_get_full_name (delegate);
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.26171 = ctx->ip_offset;
      D.26188 = monoeg_g_strdup_printf ("Delegate type %s with bad Invoke method at 0x%04x", name, D.26171);
      vinfo->info.message = D.26188;
      vinfo->exception_type = 3;
      D.26173 = ctx->list;
      D.26189 = monoeg_g_slist_prepend (D.26173, vinfo);
      ctx->list = D.26189;
    }
    ctx->valid = 0;
    monoeg_g_free (name);
    return;
  }
  <D.26185>:
  if (ip_offset > 5) goto <D.26193>; else goto <D.26191>;
  <D.26193>:
  D.26194 = ip_offset + 4294967290;
  D.26195 = ip + D.26194;
  D.26196 = *D.26195;
  if (D.26196 == 254) goto <D.26197>; else goto <D.26191>;
  <D.26197>:
  D.26198 = ctx->code;
  D.26199 = ip_offset * 12;
  D.26200 = D.26199 + 4294967224;
  D.26201 = D.26198 + D.26200;
  D.26202 = D.26201->flags;
  D.26203 = (int) D.26202;
  D.26204 = D.26203 & 1;
  if (D.26204 != 0) goto <D.26205>; else goto <D.26191>;
  <D.26205>:
  D.26206 = ip_offset + 4294967291;
  D.26207 = ip + D.26206;
  D.26208 = *D.26207;
  if (D.26208 == 6) goto <D.26209>; else goto <D.26191>;
  <D.26209>:
  D.26210 = method->flags;
  D.26211 = (int) D.26210;
  D.26212 = D.26211 & 16;
  if (D.26212 != 0) goto <D.26213>; else goto <D.26191>;
  <D.26213>:
  iftmp.96 = 1;
  goto <D.26192>;
  <D.26191>:
  iftmp.96 = 0;
  <D.26192>:
  is_static_ldftn = iftmp.96;
  if (is_static_ldftn != 0) goto <D.26214>; else goto <D.26215>;
  <D.26214>:
  D.26216 = mono_method_signature (invoke);
  D.26217 = D.26216->param_count;
  D.26218 = (int) D.26217;
  D.26219 = D.26218 + 1;
  D.26220 = mono_method_signature (method);
  D.26221 = D.26220->param_count;
  D.26222 = (int) D.26221;
  D.26223 = D.26219 == D.26222;
  is_first_arg_bound = (gboolean) D.26223;
  <D.26215>:
  D.26224 = mono_method_signature (invoke);
  D.26225 = mono_method_signature (method);
  D.26226 = mono_delegate_signature_equal (D.26224, D.26225, is_first_arg_bound);
  if (D.26226 == 0) goto <D.26227>; else goto <D.26228>;
  <D.26227>:
  {
    char * fun_sig;
    char * invoke_sig;

    D.26229 = mono_method_signature (method);
    fun_sig = mono_signature_get_desc (D.26229, 0);
    D.26230 = mono_method_signature (invoke);
    invoke_sig = mono_signature_get_desc (D.26230, 0);
    D.26167 = ctx->verifiable;
    if (D.26167 != 0) goto <D.26231>; else goto <D.26233>;
    <D.26233>:
    D.26169 = ctx->level;
    D.26170 = D.26169 & 128;
    if (D.26170 != 0) goto <D.26231>; else goto <D.26232>;
    <D.26231>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 8;
      D.26171 = ctx->ip_offset;
      D.26234 = monoeg_g_strdup_printf ("Function pointer signature \'%s\' doesn\'t match delegate\'s signature \'%s\' at 0x%04x", fun_sig, invoke_sig, D.26171);
      vinfo->info.message = D.26234;
      vinfo->exception_type = 4;
      D.26173 = ctx->list;
      D.26235 = monoeg_g_slist_prepend (D.26173, vinfo);
      ctx->list = D.26235;
    }
    ctx->verifiable = 0;
    D.26169 = ctx->level;
    D.26175 = D.26169 & 16;
    if (D.26175 != 0) goto <D.26236>; else goto <D.26237>;
    <D.26236>:
    ctx->valid = 0;
    <D.26237>:
    <D.26232>:
    monoeg_g_free (fun_sig);
    monoeg_g_free (invoke_sig);
  }
  <D.26228>:
  if (ip_offset > 5) goto <D.26240>; else goto <D.26238>;
  <D.26240>:
  D.26194 = ip_offset + 4294967290;
  D.26195 = ip + D.26194;
  D.26196 = *D.26195;
  if (D.26196 == 254) goto <D.26241>; else goto <D.26238>;
  <D.26241>:
  D.26198 = ctx->code;
  D.26199 = ip_offset * 12;
  D.26200 = D.26199 + 4294967224;
  D.26201 = D.26198 + D.26200;
  D.26202 = D.26201->flags;
  D.26203 = (int) D.26202;
  D.26204 = D.26203 & 1;
  if (D.26204 != 0) goto <D.26242>; else goto <D.26238>;
  <D.26242>:
  D.26206 = ip_offset + 4294967291;
  D.26207 = ip + D.26206;
  D.26208 = *D.26207;
  if (D.26208 == 6) goto <D.26243>; else goto <D.26238>;
  <D.26243>:
  verify_ldftn_delegate (ctx, delegate, value, funptr);
  goto <D.26239>;
  <D.26238>:
  if (ip_offset > 6) goto <D.26246>; else goto <D.26244>;
  <D.26246>:
  D.26247 = ip_offset + 4294967289;
  D.26248 = ip + D.26247;
  D.26249 = *D.26248;
  if (D.26249 == 37) goto <D.26250>; else goto <D.26244>;
  <D.26250>:
  D.26198 = ctx->code;
  D.26199 = ip_offset * 12;
  D.26251 = D.26199 + 4294967212;
  D.26252 = D.26198 + D.26251;
  D.26253 = D.26252->flags;
  D.26254 = (int) D.26253;
  D.26255 = D.26254 & 1;
  if (D.26255 != 0) goto <D.26256>; else goto <D.26244>;
  <D.26256>:
  D.26194 = ip_offset + 4294967290;
  D.26195 = ip + D.26194;
  D.26196 = *D.26195;
  if (D.26196 == 254) goto <D.26257>; else goto <D.26244>;
  <D.26257>:
  D.26198 = ctx->code;
  D.26199 = ip_offset * 12;
  D.26200 = D.26199 + 4294967224;
  D.26201 = D.26198 + D.26200;
  D.26202 = D.26201->flags;
  D.26203 = (int) D.26202;
  D.26204 = D.26203 & 1;
  if (D.26204 != 0) goto <D.26258>; else goto <D.26244>;
  <D.26258>:
  D.26206 = ip_offset + 4294967291;
  D.26207 = ip + D.26206;
  D.26208 = *D.26207;
  if (D.26208 == 7) goto <D.26259>; else goto <D.26244>;
  <D.26259>:
  D.26198 = ctx->code;
  D.26199 = ip_offset * 12;
  D.26200 = D.26199 + 4294967224;
  D.26201 = D.26198 + D.26200;
  D.26198 = ctx->code;
  D.26199 = ip_offset * 12;
  D.26200 = D.26199 + 4294967224;
  D.26201 = D.26198 + D.26200;
  D.26202 = D.26201->flags;
  D.26260 = D.26202 | 16;
  D.26201->flags = D.26260;
  goto <D.26245>;
  <D.26244>:
  D.26167 = ctx->verifiable;
  if (D.26167 != 0) goto <D.26261>; else goto <D.26263>;
  <D.26263>:
  D.26169 = ctx->level;
  D.26170 = D.26169 & 128;
  if (D.26170 != 0) goto <D.26261>; else goto <D.26262>;
  <D.26261>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26171 = ctx->ip_offset;
    D.26264 = monoeg_g_strdup_printf ("Invalid code sequence for delegate creation at 0x%04x", D.26171);
    vinfo->info.message = D.26264;
    vinfo->exception_type = 4;
    D.26173 = ctx->list;
    D.26265 = monoeg_g_slist_prepend (D.26173, vinfo);
    ctx->list = D.26265;
  }
  ctx->verifiable = 0;
  D.26169 = ctx->level;
  D.26175 = D.26169 & 16;
  if (D.26175 != 0) goto <D.26266>; else goto <D.26267>;
  <D.26266>:
  ctx->valid = 0;
  <D.26267>:
  <D.26262>:
  <D.26245>:
  <D.26239>:
  D.26198 = ctx->code;
  D.26199 = ip_offset * 12;
  D.26268 = D.26198 + D.26199;
  D.26198 = ctx->code;
  D.26199 = ip_offset * 12;
  D.26268 = D.26198 + D.26199;
  D.26269 = D.26268->flags;
  D.26270 = D.26269 | 16;
  D.26268->flags = D.26270;
  if (is_first_arg_bound != 0) goto <D.26271>; else goto <D.26272>;
  <D.26271>:
  D.26275 = mono_method_signature (method);
  D.26276 = D.26275->param_count;
  if (D.26276 == 0) goto <D.26273>; else goto <D.26277>;
  <D.26277>:
  D.26278 = mono_method_signature (method);
  D.26279 = D.26278->params[0];
  D.26280 = verify_stack_type_compatibility_full (ctx, D.26279, value, 0, 1);
  if (D.26280 == 0) goto <D.26273>; else goto <D.26274>;
  <D.26273>:
  D.26167 = ctx->verifiable;
  if (D.26167 != 0) goto <D.26281>; else goto <D.26283>;
  <D.26283>:
  D.26169 = ctx->level;
  D.26170 = D.26169 & 128;
  if (D.26170 != 0) goto <D.26281>; else goto <D.26282>;
  <D.26281>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26171 = ctx->ip_offset;
    D.26284 = monoeg_g_strdup_printf ("This object not compatible with function pointer for delegate creation at 0x%04x", D.26171);
    vinfo->info.message = D.26284;
    vinfo->exception_type = 4;
    D.26173 = ctx->list;
    D.26285 = monoeg_g_slist_prepend (D.26173, vinfo);
    ctx->list = D.26285;
  }
  ctx->verifiable = 0;
  D.26169 = ctx->level;
  D.26175 = D.26169 & 16;
  if (D.26175 != 0) goto <D.26286>; else goto <D.26287>;
  <D.26286>:
  ctx->valid = 0;
  <D.26287>:
  <D.26282>:
  <D.26274>:
  goto <D.26288>;
  <D.26272>:
  D.26210 = method->flags;
  D.26211 = (int) D.26210;
  D.26212 = D.26211 & 16;
  if (D.26212 != 0) goto <D.26289>; else goto <D.26290>;
  <D.26289>:
  D.26291 = stack_slot_is_null_literal (value);
  if (D.26291 == 0) goto <D.26292>; else goto <D.26293>;
  <D.26292>:
  if (is_first_arg_bound == 0) goto <D.26294>; else goto <D.26295>;
  <D.26294>:
  D.26167 = ctx->verifiable;
  if (D.26167 != 0) goto <D.26296>; else goto <D.26298>;
  <D.26298>:
  D.26169 = ctx->level;
  D.26170 = D.26169 & 128;
  if (D.26170 != 0) goto <D.26296>; else goto <D.26297>;
  <D.26296>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26171 = ctx->ip_offset;
    D.26299 = monoeg_g_strdup_printf ("Non-null this args used with static function for delegate creation at 0x%04x", D.26171);
    vinfo->info.message = D.26299;
    vinfo->exception_type = 4;
    D.26173 = ctx->list;
    D.26300 = monoeg_g_slist_prepend (D.26173, vinfo);
    ctx->list = D.26300;
  }
  ctx->verifiable = 0;
  D.26169 = ctx->level;
  D.26175 = D.26169 & 16;
  if (D.26175 != 0) goto <D.26301>; else goto <D.26302>;
  <D.26301>:
  ctx->valid = 0;
  <D.26302>:
  <D.26297>:
  <D.26295>:
  <D.26293>:
  goto <D.26303>;
  <D.26290>:
  D.26304 = method->klass;
  D.26305 = &D.26304->byval_arg;
  D.26306 = verify_stack_type_compatibility_full (ctx, D.26305, value, 0, 1);
  if (D.26306 == 0) goto <D.26307>; else goto <D.26308>;
  <D.26307>:
  D.26309 = stack_slot_is_null_literal (value);
  if (D.26309 == 0) goto <D.26310>; else goto <D.26311>;
  <D.26310>:
  D.26167 = ctx->verifiable;
  if (D.26167 != 0) goto <D.26312>; else goto <D.26314>;
  <D.26314>:
  D.26169 = ctx->level;
  D.26170 = D.26169 & 128;
  if (D.26170 != 0) goto <D.26312>; else goto <D.26313>;
  <D.26312>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26171 = ctx->ip_offset;
    D.26315 = monoeg_g_strdup_printf ("This object not compatible with function pointer for delegate creation at 0x%04x", D.26171);
    vinfo->info.message = D.26315;
    vinfo->exception_type = 4;
    D.26173 = ctx->list;
    D.26316 = monoeg_g_slist_prepend (D.26173, vinfo);
    ctx->list = D.26316;
  }
  ctx->verifiable = 0;
  D.26169 = ctx->level;
  D.26175 = D.26169 & 16;
  if (D.26175 != 0) goto <D.26317>; else goto <D.26318>;
  <D.26317>:
  ctx->valid = 0;
  <D.26318>:
  <D.26313>:
  <D.26311>:
  <D.26308>:
  <D.26303>:
  <D.26288>:
  D.26319 = stack_slot_get_type (value);
  if (D.26319 != 6) goto <D.26320>; else goto <D.26321>;
  <D.26320>:
  D.26167 = ctx->verifiable;
  if (D.26167 != 0) goto <D.26322>; else goto <D.26324>;
  <D.26324>:
  D.26169 = ctx->level;
  D.26170 = D.26169 & 128;
  if (D.26170 != 0) goto <D.26322>; else goto <D.26323>;
  <D.26322>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26171 = ctx->ip_offset;
    D.26325 = monoeg_g_strdup_printf ("Invalid first parameter for delegate creation at 0x%04x", D.26171);
    vinfo->info.message = D.26325;
    vinfo->exception_type = 4;
    D.26173 = ctx->list;
    D.26326 = monoeg_g_slist_prepend (D.26173, vinfo);
    ctx->list = D.26326;
  }
  ctx->verifiable = 0;
  D.26169 = ctx->level;
  D.26175 = D.26169 & 16;
  if (D.26175 != 0) goto <D.26327>; else goto <D.26328>;
  <D.26327>:
  ctx->valid = 0;
  <D.26328>:
  <D.26323>:
  <D.26321>:
}


verify_ldftn_delegate (struct VerifyContext * ctx, struct MonoClass * delegate, struct ILStackDesc * value, struct ILStackDesc * funptr)
{
  short unsigned int D.26330;
  unsigned int D.26331;
  unsigned int D.26332;
  struct MonoClass * D.26335;
  unsigned int D.26336;
  unsigned int D.26337;
  int D.26340;
  int D.26343;
  int D.26344;
  int D.26347;
  int D.26352;
  int D.26354;
  unsigned int D.26355;
  gchar * D.26356;
  struct GSList * D.26357;
  struct GSList * D.26358;
  struct MonoMethod * D.26361;
  short unsigned int D.26362;
  int D.26363;
  int D.26364;
  gchar * D.26370;
  struct GSList * D.26371;
  int D.26374;
  gchar * D.26380;
  struct GSList * D.26381;
  struct ILCodeDesc * D.26384;
  unsigned int D.26385;
  struct ILCodeDesc * D.26386;
  short unsigned int D.26387;
  short unsigned int D.26388;
  struct MonoMethod * method;

  method = funptr->method;
  D.26330 = method->flags;
  D.26331 = (unsigned int) D.26330;
  D.26332 = D.26331 & 96;
  if (D.26332 == 64) goto <D.26333>; else goto <D.26334>;
  <D.26333>:
  D.26335 = method->klass;
  D.26336 = D.26335->flags;
  D.26337 = D.26336 & 256;
  if (D.26337 == 0) goto <D.26338>; else goto <D.26339>;
  <D.26338>:
  D.26340 = stack_slot_is_boxed_value (value);
  if (D.26340 == 0) goto <D.26341>; else goto <D.26342>;
  <D.26341>:
  D.26343 = ctx->level;
  D.26344 = D.26343 & 16;
  if (D.26344 != 0) goto <D.26345>; else goto <D.26346>;
  <D.26345>:
  D.26347 = ctx->has_this_store;
  if (D.26347 != 0) goto <D.26348>; else goto <D.26349>;
  <D.26348>:
  D.26352 = ctx->verifiable;
  if (D.26352 != 0) goto <D.26350>; else goto <D.26353>;
  <D.26353>:
  D.26343 = ctx->level;
  D.26354 = D.26343 & 128;
  if (D.26354 != 0) goto <D.26350>; else goto <D.26351>;
  <D.26350>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26355 = ctx->ip_offset;
    D.26356 = monoeg_g_strdup_printf ("Invalid ldftn with virtual function in method with stdarg 0 at  0x%04x", D.26355);
    vinfo->info.message = D.26356;
    vinfo->exception_type = 4;
    D.26357 = ctx->list;
    D.26358 = monoeg_g_slist_prepend (D.26357, vinfo);
    ctx->list = D.26358;
  }
  ctx->verifiable = 0;
  D.26343 = ctx->level;
  D.26344 = D.26343 & 16;
  if (D.26344 != 0) goto <D.26359>; else goto <D.26360>;
  <D.26359>:
  ctx->valid = 0;
  <D.26360>:
  <D.26351>:
  <D.26349>:
  <D.26346>:
  D.26361 = ctx->method;
  D.26362 = D.26361->flags;
  D.26363 = (int) D.26362;
  D.26364 = D.26363 & 16;
  if (D.26364 != 0) goto <D.26365>; else goto <D.26366>;
  <D.26365>:
  D.26352 = ctx->verifiable;
  if (D.26352 != 0) goto <D.26367>; else goto <D.26369>;
  <D.26369>:
  D.26343 = ctx->level;
  D.26354 = D.26343 & 128;
  if (D.26354 != 0) goto <D.26367>; else goto <D.26368>;
  <D.26367>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26355 = ctx->ip_offset;
    D.26370 = monoeg_g_strdup_printf ("Invalid ldftn with virtual function at 0x%04x", D.26355);
    vinfo->info.message = D.26370;
    vinfo->exception_type = 4;
    D.26357 = ctx->list;
    D.26371 = monoeg_g_slist_prepend (D.26357, vinfo);
    ctx->list = D.26371;
  }
  ctx->verifiable = 0;
  D.26343 = ctx->level;
  D.26344 = D.26343 & 16;
  if (D.26344 != 0) goto <D.26372>; else goto <D.26373>;
  <D.26372>:
  ctx->valid = 0;
  <D.26373>:
  <D.26368>:
  <D.26366>:
  D.26374 = stack_slot_is_this_pointer (value);
  if (D.26374 == 0) goto <D.26375>; else goto <D.26376>;
  <D.26375>:
  D.26352 = ctx->verifiable;
  if (D.26352 != 0) goto <D.26377>; else goto <D.26379>;
  <D.26379>:
  D.26343 = ctx->level;
  D.26354 = D.26343 & 128;
  if (D.26354 != 0) goto <D.26377>; else goto <D.26378>;
  <D.26377>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26355 = ctx->ip_offset;
    D.26380 = monoeg_g_strdup_printf ("Invalid object argument, it is not the this pointer, to ldftn with virtual method at  0x%04x", D.26355);
    vinfo->info.message = D.26380;
    vinfo->exception_type = 4;
    D.26357 = ctx->list;
    D.26381 = monoeg_g_slist_prepend (D.26357, vinfo);
    ctx->list = D.26381;
  }
  ctx->verifiable = 0;
  D.26343 = ctx->level;
  D.26344 = D.26343 & 16;
  if (D.26344 != 0) goto <D.26382>; else goto <D.26383>;
  <D.26382>:
  ctx->valid = 0;
  <D.26383>:
  <D.26378>:
  <D.26376>:
  D.26384 = ctx->code;
  D.26355 = ctx->ip_offset;
  D.26385 = D.26355 * 12;
  D.26386 = D.26384 + D.26385;
  D.26384 = ctx->code;
  D.26355 = ctx->ip_offset;
  D.26385 = D.26355 * 12;
  D.26386 = D.26384 + D.26385;
  D.26387 = D.26386->flags;
  D.26388 = D.26387 | 32;
  D.26386->flags = D.26388;
  <D.26342>:
  <D.26339>:
  <D.26334>:
}


do_cast (struct VerifyContext * ctx, int token, const char * opcode)
{
  int D.26389;
  unsigned char D.26394;
  unsigned char D.26395;
  unsigned int D.26398;
  gchar * D.26399;
  struct GSList * D.26400;
  struct GSList * D.26401;
  int D.26402;
  int D.26407;
  int D.26409;
  int D.26410;
  gchar * D.26411;
  struct GSList * D.26412;
  int D.26413;
  struct MonoType * D.26417;
  int D.26418;
  gchar * D.26426;
  struct GSList * D.26427;
  unsigned char D.26430;
  int D.26431;
  gchar * D.26435;
  struct GSList * D.26436;
  int iftmp.97;
  int D.26445;
  struct MonoClass * D.26447;
  unsigned char D.26448;
  unsigned char D.26449;
  int iftmp.98;
  struct ILStackDesc * value;
  struct MonoType * type;
  gboolean is_boxed;
  gboolean do_box;

  D.26389 = check_underflow (ctx, 1);
  if (D.26389 == 0) goto <D.26390>; else goto <D.26391>;
  <D.26390>:
  return;
  <D.26391>:
  type = get_boxable_mono_type (ctx, token, opcode);
  if (type == 0B) goto <D.26392>; else goto <D.26393>;
  <D.26392>:
  return;
  <D.26393>:
  D.26394 = BIT_FIELD_REF <*type, 8, 56>;
  D.26395 = D.26394 & 64;
  if (D.26395 != 0) goto <D.26396>; else goto <D.26397>;
  <D.26396>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.26398 = ctx->ip_offset;
    D.26399 = monoeg_g_strdup_printf ("Invalid %s type at 0x%04x", opcode, D.26398);
    vinfo->info.message = D.26399;
    vinfo->exception_type = 3;
    D.26400 = ctx->list;
    D.26401 = monoeg_g_slist_prepend (D.26400, vinfo);
    ctx->list = D.26401;
  }
  ctx->valid = 0;
  return;
  <D.26397>:
  value = stack_pop (ctx);
  is_boxed = stack_slot_is_boxed_value (value);
  D.26402 = stack_slot_is_managed_pointer (value);
  if (D.26402 != 0) goto <D.26403>; else goto <D.26404>;
  <D.26403>:
  D.26407 = ctx->verifiable;
  if (D.26407 != 0) goto <D.26405>; else goto <D.26408>;
  <D.26408>:
  D.26409 = ctx->level;
  D.26410 = D.26409 & 128;
  if (D.26410 != 0) goto <D.26405>; else goto <D.26406>;
  <D.26405>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26398 = ctx->ip_offset;
    D.26411 = monoeg_g_strdup_printf ("Invalid value for %s at 0x%04x", opcode, D.26398);
    vinfo->info.message = D.26411;
    vinfo->exception_type = 4;
    D.26400 = ctx->list;
    D.26412 = monoeg_g_slist_prepend (D.26400, vinfo);
    ctx->list = D.26412;
  }
  ctx->verifiable = 0;
  D.26409 = ctx->level;
  D.26413 = D.26409 & 16;
  if (D.26413 != 0) goto <D.26414>; else goto <D.26415>;
  <D.26414>:
  ctx->valid = 0;
  <D.26415>:
  <D.26406>:
  goto <D.26416>;
  <D.26404>:
  D.26417 = value->type;
  D.26418 = mono_type_is_reference (D.26417);
  if (D.26418 == 0) goto <D.26419>; else goto <D.26420>;
  <D.26419>:
  if (is_boxed == 0) goto <D.26421>; else goto <D.26422>;
  <D.26421>:
  {
    char * name;

    name = stack_slot_full_name (value);
    D.26407 = ctx->verifiable;
    if (D.26407 != 0) goto <D.26423>; else goto <D.26425>;
    <D.26425>:
    D.26409 = ctx->level;
    D.26410 = D.26409 & 128;
    if (D.26410 != 0) goto <D.26423>; else goto <D.26424>;
    <D.26423>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 8;
      D.26398 = ctx->ip_offset;
      D.26426 = monoeg_g_strdup_printf ("Expected a reference type on stack for %s but found %s at 0x%04x", opcode, name, D.26398);
      vinfo->info.message = D.26426;
      vinfo->exception_type = 4;
      D.26400 = ctx->list;
      D.26427 = monoeg_g_slist_prepend (D.26400, vinfo);
      ctx->list = D.26427;
    }
    ctx->verifiable = 0;
    D.26409 = ctx->level;
    D.26413 = D.26409 & 16;
    if (D.26413 != 0) goto <D.26428>; else goto <D.26429>;
    <D.26428>:
    ctx->valid = 0;
    <D.26429>:
    <D.26424>:
    monoeg_g_free (name);
  }
  <D.26422>:
  <D.26420>:
  <D.26416>:
  D.26417 = value->type;
  D.26430 = D.26417->type;
  D.26431 = (int) D.26430;
  switch (D.26431) <default: <D.26439>, case 15: <D.21279>, case 22: <D.21280>, case 27: <D.21278>>
  <D.21278>:
  <D.21279>:
  <D.21280>:
  D.26407 = ctx->verifiable;
  if (D.26407 != 0) goto <D.26432>; else goto <D.26434>;
  <D.26434>:
  D.26409 = ctx->level;
  D.26410 = D.26409 & 128;
  if (D.26410 != 0) goto <D.26432>; else goto <D.26433>;
  <D.26432>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26398 = ctx->ip_offset;
    D.26435 = monoeg_g_strdup_printf ("Invalid value for %s at 0x%04x", opcode, D.26398);
    vinfo->info.message = D.26435;
    vinfo->exception_type = 4;
    D.26400 = ctx->list;
    D.26436 = monoeg_g_slist_prepend (D.26400, vinfo);
    ctx->list = D.26436;
  }
  ctx->verifiable = 0;
  D.26409 = ctx->level;
  D.26413 = D.26409 & 16;
  if (D.26413 != 0) goto <D.26437>; else goto <D.26438>;
  <D.26437>:
  ctx->valid = 0;
  <D.26438>:
  <D.26433>:
  <D.26439>:
  if (is_boxed != 0) goto <D.26441>; else goto <D.26444>;
  <D.26444>:
  D.26445 = mono_type_is_generic_argument (type);
  if (D.26445 != 0) goto <D.26441>; else goto <D.26446>;
  <D.26446>:
  D.26447 = mono_class_from_mono_type (type);
  D.26448 = BIT_FIELD_REF <*D.26447, 8, 160>;
  D.26449 = D.26448 & 8;
  if (D.26449 != 0) goto <D.26441>; else goto <D.26442>;
  <D.26441>:
  iftmp.97 = 1;
  goto <D.26443>;
  <D.26442>:
  iftmp.97 = 0;
  <D.26443>:
  do_box = iftmp.97;
  if (do_box != 0) goto <D.26451>; else goto <D.26452>;
  <D.26451>:
  iftmp.98 = 4102;
  goto <D.26453>;
  <D.26452>:
  iftmp.98 = 6;
  <D.26453>:
  stack_push_val (ctx, iftmp.98, type);
}


do_unbox_value (struct VerifyContext * ctx, int klass_token)
{
  int D.26457;
  struct MonoClass * D.26460;
  unsigned char D.26461;
  unsigned char D.26462;
  int D.26467;
  int D.26469;
  int D.26470;
  unsigned int D.26471;
  gchar * D.26472;
  struct GSList * D.26473;
  struct GSList * D.26474;
  int D.26475;
  int D.26480;
  int D.26482;
  struct MonoType * D.26484;
  struct MonoClass * D.26485;
  unsigned char D.26486;
  unsigned char D.26487;
  const char * D.26491;
  gchar * D.26492;
  struct GSList * D.26493;
  struct MonoType * D.26496;
  int D.26497;
  int D.26498;
  struct ILStackDesc * value;
  struct MonoType * type;

  type = get_boxable_mono_type (ctx, klass_token, "unbox");
  if (type == 0B) goto <D.26455>; else goto <D.26456>;
  <D.26455>:
  return;
  <D.26456>:
  D.26457 = check_underflow (ctx, 1);
  if (D.26457 == 0) goto <D.26458>; else goto <D.26459>;
  <D.26458>:
  return;
  <D.26459>:
  D.26460 = mono_class_from_mono_type (type);
  D.26461 = BIT_FIELD_REF <*D.26460, 8, 160>;
  D.26462 = D.26461 & 8;
  if (D.26462 == 0) goto <D.26463>; else goto <D.26464>;
  <D.26463>:
  D.26467 = ctx->verifiable;
  if (D.26467 != 0) goto <D.26465>; else goto <D.26468>;
  <D.26468>:
  D.26469 = ctx->level;
  D.26470 = D.26469 & 128;
  if (D.26470 != 0) goto <D.26465>; else goto <D.26466>;
  <D.26465>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26471 = ctx->ip_offset;
    D.26472 = monoeg_g_strdup_printf ("Invalid reference type for unbox at 0x%04x", D.26471);
    vinfo->info.message = D.26472;
    vinfo->exception_type = 4;
    D.26473 = ctx->list;
    D.26474 = monoeg_g_slist_prepend (D.26473, vinfo);
    ctx->list = D.26474;
  }
  ctx->verifiable = 0;
  D.26469 = ctx->level;
  D.26475 = D.26469 & 16;
  if (D.26475 != 0) goto <D.26476>; else goto <D.26477>;
  <D.26476>:
  ctx->valid = 0;
  <D.26477>:
  <D.26466>:
  <D.26464>:
  value = stack_pop (ctx);
  D.26480 = stack_slot_get_type (value);
  if (D.26480 != 6) goto <D.26478>; else goto <D.26481>;
  <D.26481>:
  D.26482 = stack_slot_is_boxed_value (value);
  if (D.26482 == 0) goto <D.26483>; else goto <D.26479>;
  <D.26483>:
  D.26484 = value->type;
  D.26485 = mono_class_from_mono_type (D.26484);
  D.26486 = BIT_FIELD_REF <*D.26485, 8, 160>;
  D.26487 = D.26486 & 8;
  if (D.26487 != 0) goto <D.26478>; else goto <D.26479>;
  <D.26478>:
  D.26467 = ctx->verifiable;
  if (D.26467 != 0) goto <D.26488>; else goto <D.26490>;
  <D.26490>:
  D.26469 = ctx->level;
  D.26470 = D.26469 & 128;
  if (D.26470 != 0) goto <D.26488>; else goto <D.26489>;
  <D.26488>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26491 = stack_slot_get_name (value);
    D.26471 = ctx->ip_offset;
    D.26492 = monoeg_g_strdup_printf ("Invalid type %s at stack for unbox operation at 0x%04x", D.26491, D.26471);
    vinfo->info.message = D.26492;
    vinfo->exception_type = 4;
    D.26473 = ctx->list;
    D.26493 = monoeg_g_slist_prepend (D.26473, vinfo);
    ctx->list = D.26493;
  }
  ctx->verifiable = 0;
  D.26469 = ctx->level;
  D.26475 = D.26469 & 16;
  if (D.26475 != 0) goto <D.26494>; else goto <D.26495>;
  <D.26494>:
  ctx->valid = 0;
  <D.26495>:
  <D.26489>:
  <D.26479>:
  value = stack_push (ctx);
  D.26496 = mono_type_get_type_byref (type);
  set_stack_value (ctx, value, D.26496, 0);
  D.26497 = value->stype;
  D.26498 = D.26497 | 512;
  value->stype = D.26498;
}


do_throw (struct VerifyContext * ctx)
{
  int D.26500;
  int D.26505;
  int D.26508;
  struct MonoType * D.26510;
  struct MonoClass * D.26511;
  unsigned char D.26512;
  unsigned char D.26513;
  int D.26516;
  int D.26518;
  int D.26519;
  unsigned int D.26520;
  gchar * D.26521;
  struct GSList * D.26522;
  struct GSList * D.26523;
  int D.26524;
  int D.26527;
  int D.26530;
  gchar * D.26536;
  struct GSList * D.26537;
  struct ILStackDesc * exception;

  D.26500 = check_underflow (ctx, 1);
  if (D.26500 == 0) goto <D.26501>; else goto <D.26502>;
  <D.26501>:
  return;
  <D.26502>:
  exception = stack_pop (ctx);
  D.26505 = stack_slot_is_null_literal (exception);
  if (D.26505 == 0) goto <D.26506>; else goto <D.26507>;
  <D.26506>:
  D.26508 = stack_slot_get_type (exception);
  if (D.26508 != 6) goto <D.26503>; else goto <D.26509>;
  <D.26509>:
  D.26510 = exception->type;
  D.26511 = mono_class_from_mono_type (D.26510);
  D.26512 = BIT_FIELD_REF <*D.26511, 8, 160>;
  D.26513 = D.26512 & 8;
  if (D.26513 != 0) goto <D.26503>; else goto <D.26504>;
  <D.26503>:
  D.26516 = ctx->verifiable;
  if (D.26516 != 0) goto <D.26514>; else goto <D.26517>;
  <D.26517>:
  D.26518 = ctx->level;
  D.26519 = D.26518 & 128;
  if (D.26519 != 0) goto <D.26514>; else goto <D.26515>;
  <D.26514>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26520 = ctx->ip_offset;
    D.26521 = monoeg_g_strdup_printf ("Invalid type on stack for throw, expected reference type at 0x%04x", D.26520);
    vinfo->info.message = D.26521;
    vinfo->exception_type = 4;
    D.26522 = ctx->list;
    D.26523 = monoeg_g_slist_prepend (D.26522, vinfo);
    ctx->list = D.26523;
  }
  ctx->verifiable = 0;
  D.26518 = ctx->level;
  D.26524 = D.26518 & 16;
  if (D.26524 != 0) goto <D.26525>; else goto <D.26526>;
  <D.26525>:
  ctx->valid = 0;
  <D.26526>:
  <D.26515>:
  <D.26504>:
  <D.26507>:
  D.26510 = exception->type;
  D.26527 = mono_type_is_generic_argument (D.26510);
  if (D.26527 != 0) goto <D.26528>; else goto <D.26529>;
  <D.26528>:
  D.26530 = stack_slot_is_boxed_value (exception);
  if (D.26530 == 0) goto <D.26531>; else goto <D.26532>;
  <D.26531>:
  {
    char * name;

    D.26510 = exception->type;
    name = mono_type_full_name (D.26510);
    D.26516 = ctx->verifiable;
    if (D.26516 != 0) goto <D.26533>; else goto <D.26535>;
    <D.26535>:
    D.26518 = ctx->level;
    D.26519 = D.26518 & 128;
    if (D.26519 != 0) goto <D.26533>; else goto <D.26534>;
    <D.26533>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 8;
      D.26520 = ctx->ip_offset;
      D.26536 = monoeg_g_strdup_printf ("Invalid type on stack for throw, expected reference type but found unboxed %s  at 0x%04x ", name, D.26520);
      vinfo->info.message = D.26536;
      vinfo->exception_type = 4;
      D.26522 = ctx->list;
      D.26537 = monoeg_g_slist_prepend (D.26522, vinfo);
      ctx->list = D.26537;
    }
    ctx->verifiable = 0;
    D.26518 = ctx->level;
    D.26524 = D.26518 & 16;
    if (D.26524 != 0) goto <D.26538>; else goto <D.26539>;
    <D.26538>:
    ctx->valid = 0;
    <D.26539>:
    <D.26534>:
    monoeg_g_free (name);
  }
  <D.26532>:
  <D.26529>:
  ctx->eval.size = 0;
}


do_push_field (struct VerifyContext * ctx, int token, gboolean take_addr)
{
  unsigned int D.26543;
  unsigned int D.26544;
  int D.26545;
  const char * iftmp.99;
  int D.26552;
  struct MonoClassField * field.100;
  struct MonoClass * D.26558;
  unsigned char D.26559;
  unsigned char D.26560;
  int D.26563;
  int D.26568;
  int D.26570;
  int D.26571;
  unsigned int D.26572;
  gchar * D.26573;
  struct GSList * D.26574;
  struct GSList * D.26575;
  int D.26576;
  struct MonoType * D.26583;
  short unsigned int D.26584;
  int D.26585;
  int D.26586;
  struct MonoMethod * D.26589;
  struct MonoClass * D.26590;
  int D.26592;
  gchar * D.26596;
  struct GSList * D.26597;
  struct ILStackDesc * D.26600;
  struct ILStackDesc * obj;
  struct MonoClassField * field;

  try
    {
      if (take_addr == 0) goto <D.26541>; else goto <D.26542>;
      <D.26541>:
      D.26543 = ctx->prefix_set;
      D.26544 = D.26543 & 4294967292;
      ctx->prefix_set = D.26544;
      <D.26542>:
      D.26545 = check_underflow (ctx, 1);
      if (D.26545 == 0) goto <D.26546>; else goto <D.26547>;
      <D.26546>:
      return;
      <D.26547>:
      obj = stack_pop_safe (ctx);
      if (take_addr != 0) goto <D.26549>; else goto <D.26550>;
      <D.26549>:
      iftmp.99 = "ldflda";
      goto <D.26551>;
      <D.26550>:
      iftmp.99 = "ldfld";
      <D.26551>:
      D.26552 = check_is_valid_type_for_field_ops (ctx, token, obj, &field, iftmp.99);
      if (D.26552 == 0) goto <D.26553>; else goto <D.26554>;
      <D.26553>:
      return;
      <D.26554>:
      if (take_addr != 0) goto <D.26555>; else goto <D.26556>;
      <D.26555>:
      field.100 = field;
      D.26558 = field.100->parent;
      D.26559 = BIT_FIELD_REF <*D.26558, 8, 160>;
      D.26560 = D.26559 & 8;
      if (D.26560 != 0) goto <D.26561>; else goto <D.26562>;
      <D.26561>:
      D.26563 = stack_slot_is_managed_pointer (obj);
      if (D.26563 == 0) goto <D.26564>; else goto <D.26565>;
      <D.26564>:
      D.26568 = ctx->verifiable;
      if (D.26568 != 0) goto <D.26566>; else goto <D.26569>;
      <D.26569>:
      D.26570 = ctx->level;
      D.26571 = D.26570 & 128;
      if (D.26571 != 0) goto <D.26566>; else goto <D.26567>;
      <D.26566>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 8;
        D.26572 = ctx->ip_offset;
        D.26573 = monoeg_g_strdup_printf ("Cannot take the address of a temporary value-type at 0x%04x", D.26572);
        vinfo->info.message = D.26573;
        vinfo->exception_type = 4;
        D.26574 = ctx->list;
        D.26575 = monoeg_g_slist_prepend (D.26574, vinfo);
        ctx->list = D.26575;
      }
      ctx->verifiable = 0;
      D.26570 = ctx->level;
      D.26576 = D.26570 & 16;
      if (D.26576 != 0) goto <D.26577>; else goto <D.26578>;
      <D.26577>:
      ctx->valid = 0;
      <D.26578>:
      <D.26567>:
      <D.26565>:
      <D.26562>:
      <D.26556>:
      if (take_addr != 0) goto <D.26581>; else goto <D.26582>;
      <D.26581>:
      field.100 = field;
      D.26583 = field.100->type;
      D.26584 = D.26583->attrs;
      D.26585 = (int) D.26584;
      D.26586 = D.26585 & 32;
      if (D.26586 != 0) goto <D.26587>; else goto <D.26588>;
      <D.26587>:
      field.100 = field;
      D.26558 = field.100->parent;
      D.26589 = ctx->method;
      D.26590 = D.26589->klass;
      if (D.26558 != D.26590) goto <D.26579>; else goto <D.26591>;
      <D.26591>:
      D.26589 = ctx->method;
      D.26592 = mono_method_is_constructor (D.26589);
      if (D.26592 == 0) goto <D.26579>; else goto <D.26580>;
      <D.26579>:
      D.26568 = ctx->verifiable;
      if (D.26568 != 0) goto <D.26593>; else goto <D.26595>;
      <D.26595>:
      D.26570 = ctx->level;
      D.26571 = D.26570 & 128;
      if (D.26571 != 0) goto <D.26593>; else goto <D.26594>;
      <D.26593>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 8;
        D.26572 = ctx->ip_offset;
        D.26596 = monoeg_g_strdup_printf ("Cannot take the address of a init-only field at 0x%04x", D.26572);
        vinfo->info.message = D.26596;
        vinfo->exception_type = 4;
        D.26574 = ctx->list;
        D.26597 = monoeg_g_slist_prepend (D.26574, vinfo);
        ctx->list = D.26597;
      }
      ctx->verifiable = 0;
      D.26570 = ctx->level;
      D.26576 = D.26570 & 16;
      if (D.26576 != 0) goto <D.26598>; else goto <D.26599>;
      <D.26598>:
      ctx->valid = 0;
      <D.26599>:
      <D.26594>:
      <D.26580>:
      <D.26588>:
      <D.26582>:
      D.26600 = stack_push (ctx);
      field.100 = field;
      D.26583 = field.100->type;
      set_stack_value (ctx, D.26600, D.26583, take_addr);
    }
  finally
    {
      field = {CLOBBER};
    }
}


check_is_valid_type_for_field_ops (struct VerifyContext * ctx, int token, struct ILStackDesc * obj, struct MonoClassField * * ret_field, const char * opcode)
{
  gboolean D.26606;
  int iftmp.101;
  int D.26611;
  int D.26613;
  struct MonoClass * D.26615;
  struct MonoType * D.26616;
  int D.26617;
  struct MonoType * D.26618;
  unsigned char D.26619;
  unsigned int D.26622;
  gchar * D.26623;
  struct GSList * D.26624;
  struct GSList * D.26625;
  struct MonoType * D.26626;
  _Bool D.26627;
  long int D.26628;
  long int D.26629;
  int D.26634;
  int D.26639;
  int D.26641;
  int D.26642;
  gchar * D.26643;
  struct GSList * D.26644;
  int D.26645;
  int D.26648;
  struct MonoMethod * D.26651;
  int D.26652;
  gchar * D.26658;
  struct GSList * D.26659;
  unsigned char D.26663;
  unsigned char D.26664;
  int D.26667;
  gchar * D.26673;
  struct GSList * D.26674;
  int D.26679;
  gchar * D.26685;
  struct GSList * D.26686;
  int D.26689;
  int D.26692;
  gchar * D.26698;
  struct GSList * D.26699;
  struct MonoClass * D.26704;
  int D.26705;
  gchar * D.26711;
  struct GSList * D.26712;
  struct MonoClassField * field;
  struct MonoClass * klass;
  gboolean is_pointer;

  try
    {
      field = verifier_load_field (ctx, token, &klass, opcode);
      if (field == 0B) goto <D.26604>; else goto <D.26605>;
      <D.26604>:
      D.26606 = 0;
      return D.26606;
      <D.26605>:
      *ret_field = field;
      D.26611 = stack_slot_get_type (obj);
      if (D.26611 == 5) goto <D.26608>; else goto <D.26612>;
      <D.26612>:
      D.26613 = stack_slot_get_type (obj);
      if (D.26613 == 3) goto <D.26614>; else goto <D.26609>;
      <D.26614>:
      D.26615 = field->parent;
      D.26616 = &D.26615->byval_arg;
      D.26617 = get_stack_type (D.26616);
      if (D.26617 == 0) goto <D.26608>; else goto <D.26609>;
      <D.26608>:
      iftmp.101 = 1;
      goto <D.26610>;
      <D.26609>:
      iftmp.101 = 0;
      <D.26610>:
      is_pointer = iftmp.101;
      D.26618 = field->type;
      D.26619 = D.26618->type;
      if (D.26619 == 22) goto <D.26620>; else goto <D.26621>;
      <D.26620>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26622 = ctx->ip_offset;
        D.26623 = monoeg_g_strdup_printf ("Typedbyref field is an unverfiable type at 0x%04x", D.26622);
        vinfo->info.message = D.26623;
        vinfo->exception_type = 3;
        D.26624 = ctx->list;
        D.26625 = monoeg_g_slist_prepend (D.26624, vinfo);
        ctx->list = D.26625;
      }
      ctx->valid = 0;
      D.26606 = 0;
      return D.26606;
      <D.26621>:
      D.26626 = obj->type;
      D.26627 = D.26626 == 0B;
      D.26628 = (long int) D.26627;
      D.26629 = __builtin_expect (D.26628, 0);
      if (D.26629 != 0) goto <D.26630>; else goto <D.26631>;
      <D.26630>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "verify.c", 3369, "obj->type");
      <D.26631>:
      if (is_pointer != 0) goto <D.26632>; else goto <D.26633>;
      <D.26632>:
      D.26634 = stack_slot_get_underlying_type (obj);
      if (D.26634 == 3) goto <D.26635>; else goto <D.26636>;
      <D.26635>:
      D.26639 = ctx->verifiable;
      if (D.26639 != 0) goto <D.26637>; else goto <D.26640>;
      <D.26640>:
      D.26641 = ctx->level;
      D.26642 = D.26641 & 128;
      if (D.26642 != 0) goto <D.26637>; else goto <D.26638>;
      <D.26637>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 8;
        D.26622 = ctx->ip_offset;
        D.26643 = monoeg_g_strdup_printf ("Native int is not a verifiable type to reference a field at 0x%04x", D.26622);
        vinfo->info.message = D.26643;
        vinfo->exception_type = 4;
        D.26624 = ctx->list;
        D.26644 = monoeg_g_slist_prepend (D.26624, vinfo);
        ctx->list = D.26644;
      }
      ctx->verifiable = 0;
      D.26641 = ctx->level;
      D.26645 = D.26641 & 16;
      if (D.26645 != 0) goto <D.26646>; else goto <D.26647>;
      <D.26646>:
      ctx->valid = 0;
      <D.26647>:
      <D.26638>:
      <D.26636>:
      D.26641 = ctx->level;
      D.26648 = D.26641 & 64;
      if (D.26648 == 0) goto <D.26649>; else goto <D.26650>;
      <D.26649>:
      D.26651 = ctx->method;
      D.26652 = mono_method_can_access_field_full (D.26651, field, 0B);
      if (D.26652 == 0) goto <D.26653>; else goto <D.26654>;
      <D.26653>:
      D.26639 = ctx->verifiable;
      if (D.26639 != 0) goto <D.26655>; else goto <D.26657>;
      <D.26657>:
      D.26641 = ctx->level;
      D.26642 = D.26641 & 128;
      if (D.26642 != 0) goto <D.26655>; else goto <D.26656>;
      <D.26655>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 8;
        D.26622 = ctx->ip_offset;
        D.26658 = monoeg_g_strdup_printf ("Type at stack is not accessible at 0x%04x", D.26622);
        vinfo->info.message = D.26658;
        vinfo->exception_type = 10;
        D.26624 = ctx->list;
        D.26659 = monoeg_g_slist_prepend (D.26624, vinfo);
        ctx->list = D.26659;
      }
      ctx->verifiable = 0;
      D.26641 = ctx->level;
      D.26645 = D.26641 & 16;
      if (D.26645 != 0) goto <D.26660>; else goto <D.26661>;
      <D.26660>:
      ctx->valid = 0;
      <D.26661>:
      <D.26656>:
      <D.26654>:
      <D.26650>:
      goto <D.26662>;
      <D.26633>:
      D.26615 = field->parent;
      D.26663 = BIT_FIELD_REF <*D.26615, 8, 160>;
      D.26664 = D.26663 & 8;
      if (D.26664 == 0) goto <D.26665>; else goto <D.26666>;
      <D.26665>:
      D.26667 = stack_slot_is_managed_pointer (obj);
      if (D.26667 != 0) goto <D.26668>; else goto <D.26669>;
      <D.26668>:
      D.26639 = ctx->verifiable;
      if (D.26639 != 0) goto <D.26670>; else goto <D.26672>;
      <D.26672>:
      D.26641 = ctx->level;
      D.26642 = D.26641 & 128;
      if (D.26642 != 0) goto <D.26670>; else goto <D.26671>;
      <D.26670>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 8;
        D.26622 = ctx->ip_offset;
        D.26673 = monoeg_g_strdup_printf ("Type at stack is a managed pointer to a reference type and is not compatible to reference the field at 0x%04x", D.26622);
        vinfo->info.message = D.26673;
        vinfo->exception_type = 4;
        D.26624 = ctx->list;
        D.26674 = monoeg_g_slist_prepend (D.26624, vinfo);
        ctx->list = D.26674;
      }
      ctx->verifiable = 0;
      D.26641 = ctx->level;
      D.26645 = D.26641 & 16;
      if (D.26645 != 0) goto <D.26675>; else goto <D.26676>;
      <D.26675>:
      ctx->valid = 0;
      <D.26676>:
      <D.26671>:
      <D.26669>:
      <D.26666>:
      D.26615 = field->parent;
      D.26663 = BIT_FIELD_REF <*D.26615, 8, 160>;
      D.26664 = D.26663 & 8;
      if (D.26664 != 0) goto <D.26677>; else goto <D.26678>;
      <D.26677>:
      D.26679 = stack_slot_is_boxed_value (obj);
      if (D.26679 != 0) goto <D.26680>; else goto <D.26681>;
      <D.26680>:
      D.26639 = ctx->verifiable;
      if (D.26639 != 0) goto <D.26682>; else goto <D.26684>;
      <D.26684>:
      D.26641 = ctx->level;
      D.26642 = D.26641 & 128;
      if (D.26642 != 0) goto <D.26682>; else goto <D.26683>;
      <D.26682>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 8;
        D.26622 = ctx->ip_offset;
        D.26685 = monoeg_g_strdup_printf ("Type at stack is a boxed valuetype and is not compatible to reference the field at 0x%04x", D.26622);
        vinfo->info.message = D.26685;
        vinfo->exception_type = 4;
        D.26624 = ctx->list;
        D.26686 = monoeg_g_slist_prepend (D.26624, vinfo);
        ctx->list = D.26686;
      }
      ctx->verifiable = 0;
      D.26641 = ctx->level;
      D.26645 = D.26641 & 16;
      if (D.26645 != 0) goto <D.26687>; else goto <D.26688>;
      <D.26687>:
      ctx->valid = 0;
      <D.26688>:
      <D.26683>:
      <D.26681>:
      <D.26678>:
      D.26689 = stack_slot_is_null_literal (obj);
      if (D.26689 == 0) goto <D.26690>; else goto <D.26691>;
      <D.26690>:
      D.26615 = field->parent;
      D.26616 = &D.26615->byval_arg;
      D.26692 = verify_stack_type_compatibility_full (ctx, D.26616, obj, 1, 0);
      if (D.26692 == 0) goto <D.26693>; else goto <D.26694>;
      <D.26693>:
      {
        char * found;
        char * expected;

        found = stack_slot_full_name (obj);
        D.26615 = field->parent;
        D.26616 = &D.26615->byval_arg;
        expected = mono_type_full_name (D.26616);
        D.26639 = ctx->verifiable;
        if (D.26639 != 0) goto <D.26695>; else goto <D.26697>;
        <D.26697>:
        D.26641 = ctx->level;
        D.26642 = D.26641 & 128;
        if (D.26642 != 0) goto <D.26695>; else goto <D.26696>;
        <D.26695>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.26622 = ctx->ip_offset;
          D.26698 = monoeg_g_strdup_printf ("Expected type \'%s\' but found \'%s\' referencing the \'this\' argument at 0x%04x", expected, found, D.26622);
          vinfo->info.message = D.26698;
          vinfo->exception_type = 4;
          D.26624 = ctx->list;
          D.26699 = monoeg_g_slist_prepend (D.26624, vinfo);
          ctx->list = D.26699;
        }
        ctx->verifiable = 0;
        D.26641 = ctx->level;
        D.26645 = D.26641 & 16;
        if (D.26645 != 0) goto <D.26700>; else goto <D.26701>;
        <D.26700>:
        ctx->valid = 0;
        <D.26701>:
        <D.26696>:
        monoeg_g_free (found);
        monoeg_g_free (expected);
      }
      <D.26694>:
      <D.26691>:
      D.26641 = ctx->level;
      D.26648 = D.26641 & 64;
      if (D.26648 == 0) goto <D.26702>; else goto <D.26703>;
      <D.26702>:
      D.26651 = ctx->method;
      D.26626 = obj->type;
      D.26704 = mono_class_from_mono_type (D.26626);
      D.26705 = mono_method_can_access_field_full (D.26651, field, D.26704);
      if (D.26705 == 0) goto <D.26706>; else goto <D.26707>;
      <D.26706>:
      D.26639 = ctx->verifiable;
      if (D.26639 != 0) goto <D.26708>; else goto <D.26710>;
      <D.26710>:
      D.26641 = ctx->level;
      D.26642 = D.26641 & 128;
      if (D.26642 != 0) goto <D.26708>; else goto <D.26709>;
      <D.26708>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 8;
        D.26622 = ctx->ip_offset;
        D.26711 = monoeg_g_strdup_printf ("Type at stack is not accessible at 0x%04x", D.26622);
        vinfo->info.message = D.26711;
        vinfo->exception_type = 10;
        D.26624 = ctx->list;
        D.26712 = monoeg_g_slist_prepend (D.26624, vinfo);
        ctx->list = D.26712;
      }
      ctx->verifiable = 0;
      D.26641 = ctx->level;
      D.26645 = D.26641 & 16;
      if (D.26645 != 0) goto <D.26713>; else goto <D.26714>;
      <D.26713>:
      ctx->valid = 0;
      <D.26714>:
      <D.26709>:
      <D.26707>:
      <D.26703>:
      <D.26662>:
      check_unmanaged_pointer (ctx, obj);
      D.26606 = 1;
      return D.26606;
    }
  finally
    {
      klass = {CLOBBER};
    }
}


verifier_load_field (struct VerifyContext * ctx, int token, struct MonoClass * * out_klass, const char * opcode)
{
  struct MonoMethod * D.26717;
  unsigned char D.26718;
  unsigned char D.26719;
  unsigned int token.102;
  struct MonoClass * iftmp.103;
  int D.26730;
  _Bool D.26731;
  _Bool D.26732;
  _Bool D.26733;
  struct MonoImage * D.26735;
  unsigned int token.104;
  int D.26737;
  unsigned int D.26738;
  gchar * D.26739;
  struct GSList * D.26740;
  struct GSList * D.26741;
  struct MonoClassField * D.26742;
  unsigned int token.105;
  struct MonoGenericContext * D.26744;
  struct MonoClass * D.26748;
  struct MonoClass * klass.106;
  struct MonoLoaderError * D.26752;
  gchar * D.26753;
  struct GSList * D.26754;
  struct MonoType * D.26755;
  int D.26756;
  unsigned int D.26759;
  unsigned int D.26760;
  const char * D.26763;
  gchar * D.26764;
  struct GSList * D.26765;
  struct MonoClassField * field;
  struct MonoClass * klass;

  try
    {
      klass = 0B;
      D.26717 = ctx->method;
      D.26718 = BIT_FIELD_REF <*D.26717, 8, 160>;
      D.26719 = D.26718 & 124;
      if (D.26719 != 0) goto <D.26720>; else goto <D.26721>;
      <D.26720>:
      D.26717 = ctx->method;
      token.102 = (unsigned int) token;
      field = mono_method_get_wrapper_data (D.26717, token.102);
      if (field != 0B) goto <D.26724>; else goto <D.26725>;
      <D.26724>:
      iftmp.103 = field->parent;
      goto <D.26726>;
      <D.26725>:
      iftmp.103 = 0B;
      <D.26726>:
      klass = iftmp.103;
      goto <D.26727>;
      <D.26721>:
      D.26730 = token >> 24;
      D.26731 = D.26730 != 4;
      D.26732 = D.26730 != 10;
      D.26733 = D.26731 & D.26732;
      if (D.26733 != 0) goto <D.26728>; else goto <D.26734>;
      <D.26734>:
      D.26735 = ctx->image;
      token.104 = (unsigned int) token;
      D.26737 = token_bounds_check (D.26735, token.104);
      if (D.26737 == 0) goto <D.26728>; else goto <D.26729>;
      <D.26728>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26738 = ctx->ip_offset;
        D.26739 = monoeg_g_strdup_printf ("Invalid field token 0x%08x for %s at 0x%04x", token, opcode, D.26738);
        vinfo->info.message = D.26739;
        vinfo->exception_type = 12;
        D.26740 = ctx->list;
        D.26741 = monoeg_g_slist_prepend (D.26740, vinfo);
        ctx->list = D.26741;
      }
      ctx->valid = 0;
      D.26742 = 0B;
      return D.26742;
      <D.26729>:
      D.26735 = ctx->image;
      token.105 = (unsigned int) token;
      D.26744 = ctx->generic_context;
      field = mono_field_from_token (D.26735, token.105, &klass, D.26744);
      <D.26727>:
      if (field == 0B) goto <D.26745>; else goto <D.26747>;
      <D.26747>:
      D.26748 = field->parent;
      if (D.26748 == 0B) goto <D.26745>; else goto <D.26749>;
      <D.26749>:
      klass.106 = klass;
      if (klass.106 == 0B) goto <D.26745>; else goto <D.26751>;
      <D.26751>:
      D.26752 = mono_loader_get_last_error ();
      if (D.26752 != 0B) goto <D.26745>; else goto <D.26746>;
      <D.26745>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26738 = ctx->ip_offset;
        D.26753 = monoeg_g_strdup_printf ("Cannot load field from token 0x%08x for %s at 0x%04x", token, opcode, D.26738);
        vinfo->info.message = D.26753;
        vinfo->exception_type = 12;
        D.26740 = ctx->list;
        D.26754 = monoeg_g_slist_prepend (D.26740, vinfo);
        ctx->list = D.26754;
      }
      ctx->valid = 0;
      mono_loader_clear_error ();
      D.26742 = 0B;
      return D.26742;
      <D.26746>:
      klass.106 = klass;
      D.26755 = &klass.106->byval_arg;
      D.26756 = mono_type_is_valid_in_context (ctx, D.26755);
      if (D.26756 == 0) goto <D.26757>; else goto <D.26758>;
      <D.26757>:
      D.26742 = 0B;
      return D.26742;
      <D.26758>:
      D.26759 = mono_field_get_flags (field);
      D.26760 = D.26759 & 64;
      if (D.26760 != 0) goto <D.26761>; else goto <D.26762>;
      <D.26761>:
      {
        char * type_name;

        D.26748 = field->parent;
        type_name = mono_type_get_full_name (D.26748);
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.26763 = field->name;
          D.26738 = ctx->ip_offset;
          D.26764 = monoeg_g_strdup_printf ("Cannot reference literal field %s::%s at 0x%04x", type_name, D.26763, D.26738);
          vinfo->info.message = D.26764;
          vinfo->exception_type = 3;
          D.26740 = ctx->list;
          D.26765 = monoeg_g_slist_prepend (D.26740, vinfo);
          ctx->list = D.26765;
        }
        ctx->valid = 0;
        monoeg_g_free (type_name);
        D.26742 = 0B;
        return D.26742;
      }
      <D.26762>:
      klass.106 = klass;
      *out_klass = klass.106;
      D.26742 = field;
      return D.26742;
    }
  finally
    {
      klass = {CLOBBER};
    }
}


do_push_static_field (struct VerifyContext * ctx, int token, gboolean take_addr)
{
  int D.26768;
  unsigned int D.26773;
  unsigned int D.26774;
  const char * iftmp.107;
  struct MonoType * D.26781;
  short unsigned int D.26782;
  int D.26783;
  int D.26784;
  unsigned int D.26787;
  gchar * D.26788;
  struct GSList * D.26789;
  struct GSList * D.26790;
  int D.26795;
  struct MonoClass * D.26798;
  struct MonoMethod * D.26799;
  struct MonoClass * D.26800;
  short unsigned int D.26802;
  int D.26803;
  int D.26804;
  int D.21065;
  int iftmp.108;
  int D.21061;
  const char[7] * D.26809;
  unsigned char D.26810;
  int D.26811;
  unsigned char D.26812;
  int D.26813;
  _Bool D.26814;
  _Bool D.26815;
  _Bool D.26816;
  const unsigned char * D.26819;
  unsigned char D.26820;
  int D.26821;
  const unsigned char * D.26822;
  unsigned char D.26823;
  int D.26824;
  _Bool D.26825;
  _Bool D.26826;
  const unsigned char * D.26829;
  unsigned char D.26830;
  int D.26831;
  const unsigned char * D.26832;
  unsigned char D.26833;
  int D.26834;
  _Bool D.26835;
  _Bool D.26836;
  const unsigned char * D.26839;
  unsigned char D.26840;
  int D.26841;
  const unsigned char * D.26842;
  unsigned char D.26843;
  int D.26844;
  const char * D.26846;
  int D.26849;
  int D.26851;
  int D.26852;
  gchar * D.26853;
  struct GSList * D.26854;
  int D.26855;
  int D.26858;
  int D.26861;
  gchar * D.26867;
  struct GSList * D.26868;
  struct ILStackDesc * D.26871;
  struct MonoClassField * field;
  struct MonoClass * klass;

  try
    {
      D.26768 = check_overflow (ctx);
      if (D.26768 == 0) goto <D.26769>; else goto <D.26770>;
      <D.26769>:
      return;
      <D.26770>:
      if (take_addr == 0) goto <D.26771>; else goto <D.26772>;
      <D.26771>:
      D.26773 = ctx->prefix_set;
      D.26774 = D.26773 & 4294967293;
      ctx->prefix_set = D.26774;
      <D.26772>:
      if (take_addr != 0) goto <D.26776>; else goto <D.26777>;
      <D.26776>:
      iftmp.107 = "ldsflda";
      goto <D.26778>;
      <D.26777>:
      iftmp.107 = "ldsfld";
      <D.26778>:
      field = verifier_load_field (ctx, token, &klass, iftmp.107);
      if (field == 0B) goto <D.26779>; else goto <D.26780>;
      <D.26779>:
      return;
      <D.26780>:
      D.26781 = field->type;
      D.26782 = D.26781->attrs;
      D.26783 = (int) D.26782;
      D.26784 = D.26783 & 16;
      if (D.26784 == 0) goto <D.26785>; else goto <D.26786>;
      <D.26785>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26787 = ctx->ip_offset;
        D.26788 = monoeg_g_strdup_printf ("Cannot load non static field at 0x%04x", D.26787);
        vinfo->info.message = D.26788;
        vinfo->exception_type = 3;
        D.26789 = ctx->list;
        D.26790 = monoeg_g_slist_prepend (D.26789, vinfo);
        ctx->list = D.26790;
      }
      ctx->valid = 0;
      return;
      <D.26786>:
      if (take_addr != 0) goto <D.26793>; else goto <D.26794>;
      <D.26793>:
      D.26781 = field->type;
      D.26782 = D.26781->attrs;
      D.26783 = (int) D.26782;
      D.26795 = D.26783 & 32;
      if (D.26795 != 0) goto <D.26796>; else goto <D.26797>;
      <D.26796>:
      D.26798 = field->parent;
      D.26799 = ctx->method;
      D.26800 = D.26799->klass;
      if (D.26798 != D.26800) goto <D.26791>; else goto <D.26801>;
      <D.26801>:
      D.26799 = ctx->method;
      D.26802 = D.26799->flags;
      D.26803 = (int) D.26802;
      D.26804 = D.26803 & 2064;
      if (D.26804 == 0) goto <D.26791>; else goto <D.26805>;
      <D.26805>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.26799 = ctx->method;
          __s2 = D.26799->name;
          D.26809 = ".cctor";
          D.26810 = MEM[(const unsigned char *)D.26809];
          D.26811 = (int) D.26810;
          D.26812 = *__s2;
          D.26813 = (int) D.26812;
          __result = D.26811 - D.26813;
          {
            D.26814 = __s1_len != 0;
            D.26815 = __result == 0;
            D.26816 = D.26814 & D.26815;
            if (D.26816 != 0) goto <D.26817>; else goto <D.26818>;
            <D.26817>:
            D.26819 = &MEM[(void *)".cctor" + 1B];
            D.26820 = *D.26819;
            D.26821 = (int) D.26820;
            D.26822 = __s2 + 1;
            D.26823 = *D.26822;
            D.26824 = (int) D.26823;
            __result = D.26821 - D.26824;
            D.26825 = __s1_len > 1;
            D.26815 = __result == 0;
            D.26826 = D.26825 & D.26815;
            if (D.26826 != 0) goto <D.26827>; else goto <D.26828>;
            <D.26827>:
            D.26829 = &MEM[(void *)".cctor" + 2B];
            D.26830 = *D.26829;
            D.26831 = (int) D.26830;
            D.26832 = __s2 + 2;
            D.26833 = *D.26832;
            D.26834 = (int) D.26833;
            __result = D.26831 - D.26834;
            D.26835 = __s1_len > 2;
            D.26815 = __result == 0;
            D.26836 = D.26835 & D.26815;
            if (D.26836 != 0) goto <D.26837>; else goto <D.26838>;
            <D.26837>:
            D.26839 = &MEM[(void *)".cctor" + 3B];
            D.26840 = *D.26839;
            D.26841 = (int) D.26840;
            D.26842 = __s2 + 3;
            D.26843 = *D.26842;
            D.26844 = (int) D.26843;
            __result = D.26841 - D.26844;
            <D.26838>:
            <D.26828>:
            <D.26818>:
          }
          D.21061 = __result;
        }
        iftmp.108 = D.21061;
        goto <D.26845>;
        <D.26808>:
        D.26799 = ctx->method;
        D.26846 = D.26799->name;
        iftmp.108 = __builtin_strcmp (".cctor", D.26846);
        <D.26845>:
        D.21065 = iftmp.108;
      }
      if (D.21065 != 0) goto <D.26791>; else goto <D.26792>;
      <D.26791>:
      D.26849 = ctx->verifiable;
      if (D.26849 != 0) goto <D.26847>; else goto <D.26850>;
      <D.26850>:
      D.26851 = ctx->level;
      D.26852 = D.26851 & 128;
      if (D.26852 != 0) goto <D.26847>; else goto <D.26848>;
      <D.26847>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 8;
        D.26787 = ctx->ip_offset;
        D.26853 = monoeg_g_strdup_printf ("Cannot take the address of a init-only field at 0x%04x", D.26787);
        vinfo->info.message = D.26853;
        vinfo->exception_type = 4;
        D.26789 = ctx->list;
        D.26854 = monoeg_g_slist_prepend (D.26789, vinfo);
        ctx->list = D.26854;
      }
      ctx->verifiable = 0;
      D.26851 = ctx->level;
      D.26855 = D.26851 & 16;
      if (D.26855 != 0) goto <D.26856>; else goto <D.26857>;
      <D.26856>:
      ctx->valid = 0;
      <D.26857>:
      <D.26848>:
      <D.26792>:
      <D.26797>:
      <D.26794>:
      D.26851 = ctx->level;
      D.26858 = D.26851 & 64;
      if (D.26858 == 0) goto <D.26859>; else goto <D.26860>;
      <D.26859>:
      D.26799 = ctx->method;
      D.26861 = mono_method_can_access_field_full (D.26799, field, 0B);
      if (D.26861 == 0) goto <D.26862>; else goto <D.26863>;
      <D.26862>:
      D.26849 = ctx->verifiable;
      if (D.26849 != 0) goto <D.26864>; else goto <D.26866>;
      <D.26866>:
      D.26851 = ctx->level;
      D.26852 = D.26851 & 128;
      if (D.26852 != 0) goto <D.26864>; else goto <D.26865>;
      <D.26864>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 8;
        D.26787 = ctx->ip_offset;
        D.26867 = monoeg_g_strdup_printf ("Type at stack is not accessible at 0x%04x", D.26787);
        vinfo->info.message = D.26867;
        vinfo->exception_type = 10;
        D.26789 = ctx->list;
        D.26868 = monoeg_g_slist_prepend (D.26789, vinfo);
        ctx->list = D.26868;
      }
      ctx->verifiable = 0;
      D.26851 = ctx->level;
      D.26855 = D.26851 & 16;
      if (D.26855 != 0) goto <D.26869>; else goto <D.26870>;
      <D.26869>:
      ctx->valid = 0;
      <D.26870>:
      <D.26865>:
      <D.26863>:
      <D.26860>:
      D.26871 = stack_push (ctx);
      D.26781 = field->type;
      set_stack_value (ctx, D.26871, D.26781, take_addr);
    }
  finally
    {
      klass = {CLOBBER};
    }
}


do_store_field (struct VerifyContext * ctx, int token)
{
  unsigned int D.26875;
  unsigned int D.26876;
  int D.26877;
  int D.26880;
  struct MonoClassField * field.109;
  struct MonoType * D.26884;
  int D.26885;
  int D.26890;
  int D.26892;
  int D.26893;
  const char * D.26894;
  unsigned int D.26895;
  gchar * D.26896;
  struct GSList * D.26897;
  struct GSList * D.26898;
  int D.26899;
  struct ILStackDesc * value;
  struct ILStackDesc * obj;
  struct MonoClassField * field;

  try
    {
      D.26875 = ctx->prefix_set;
      D.26876 = D.26875 & 4294967292;
      ctx->prefix_set = D.26876;
      D.26877 = check_underflow (ctx, 2);
      if (D.26877 == 0) goto <D.26878>; else goto <D.26879>;
      <D.26878>:
      return;
      <D.26879>:
      value = stack_pop (ctx);
      obj = stack_pop_safe (ctx);
      D.26880 = check_is_valid_type_for_field_ops (ctx, token, obj, &field, "stfld");
      if (D.26880 == 0) goto <D.26881>; else goto <D.26882>;
      <D.26881>:
      return;
      <D.26882>:
      field.109 = field;
      D.26884 = field.109->type;
      D.26885 = verify_stack_type_compatibility (ctx, D.26884, value);
      if (D.26885 == 0) goto <D.26886>; else goto <D.26887>;
      <D.26886>:
      D.26890 = ctx->verifiable;
      if (D.26890 != 0) goto <D.26888>; else goto <D.26891>;
      <D.26891>:
      D.26892 = ctx->level;
      D.26893 = D.26892 & 128;
      if (D.26893 != 0) goto <D.26888>; else goto <D.26889>;
      <D.26888>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 8;
        D.26894 = stack_slot_get_name (value);
        D.26895 = ctx->ip_offset;
        D.26896 = monoeg_g_strdup_printf ("Incompatible type %s in field store at 0x%04x", D.26894, D.26895);
        vinfo->info.message = D.26896;
        vinfo->exception_type = 4;
        D.26897 = ctx->list;
        D.26898 = monoeg_g_slist_prepend (D.26897, vinfo);
        ctx->list = D.26898;
      }
      ctx->verifiable = 0;
      D.26892 = ctx->level;
      D.26899 = D.26892 & 16;
      if (D.26899 != 0) goto <D.26900>; else goto <D.26901>;
      <D.26900>:
      ctx->valid = 0;
      <D.26901>:
      <D.26889>:
      <D.26887>:
    }
  finally
    {
      field = {CLOBBER};
    }
}


do_store_static_field (struct VerifyContext * ctx, int token)
{
  unsigned int D.26905;
  unsigned int D.26906;
  int D.26907;
  struct MonoType * D.26912;
  short unsigned int D.26913;
  int D.26914;
  int D.26915;
  unsigned int D.26918;
  gchar * D.26919;
  struct GSList * D.26920;
  struct GSList * D.26921;
  unsigned char D.26922;
  gchar * D.26925;
  struct GSList * D.26926;
  int D.26927;
  int D.26928;
  struct MonoMethod * D.26931;
  int D.26932;
  int D.26937;
  int D.26939;
  gchar * D.26940;
  struct GSList * D.26941;
  int D.26942;
  int D.26945;
  gchar * D.26951;
  struct GSList * D.26952;
  struct MonoClassField * field;
  struct MonoClass * klass;
  struct ILStackDesc * value;

  try
    {
      D.26905 = ctx->prefix_set;
      D.26906 = D.26905 & 4294967293;
      ctx->prefix_set = D.26906;
      D.26907 = check_underflow (ctx, 1);
      if (D.26907 == 0) goto <D.26908>; else goto <D.26909>;
      <D.26908>:
      return;
      <D.26909>:
      value = stack_pop (ctx);
      field = verifier_load_field (ctx, token, &klass, "stsfld");
      if (field == 0B) goto <D.26910>; else goto <D.26911>;
      <D.26910>:
      return;
      <D.26911>:
      D.26912 = field->type;
      D.26913 = D.26912->attrs;
      D.26914 = (int) D.26913;
      D.26915 = D.26914 & 16;
      if (D.26915 == 0) goto <D.26916>; else goto <D.26917>;
      <D.26916>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26918 = ctx->ip_offset;
        D.26919 = monoeg_g_strdup_printf ("Cannot store non static field at 0x%04x", D.26918);
        vinfo->info.message = D.26919;
        vinfo->exception_type = 3;
        D.26920 = ctx->list;
        D.26921 = monoeg_g_slist_prepend (D.26920, vinfo);
        ctx->list = D.26921;
      }
      ctx->valid = 0;
      return;
      <D.26917>:
      D.26912 = field->type;
      D.26922 = D.26912->type;
      if (D.26922 == 22) goto <D.26923>; else goto <D.26924>;
      <D.26923>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26918 = ctx->ip_offset;
        D.26925 = monoeg_g_strdup_printf ("Typedbyref field is an unverfiable type in store static field at 0x%04x", D.26918);
        vinfo->info.message = D.26925;
        vinfo->exception_type = 3;
        D.26920 = ctx->list;
        D.26926 = monoeg_g_slist_prepend (D.26920, vinfo);
        ctx->list = D.26926;
      }
      ctx->valid = 0;
      return;
      <D.26924>:
      D.26927 = ctx->level;
      D.26928 = D.26927 & 64;
      if (D.26928 == 0) goto <D.26929>; else goto <D.26930>;
      <D.26929>:
      D.26931 = ctx->method;
      D.26932 = mono_method_can_access_field_full (D.26931, field, 0B);
      if (D.26932 == 0) goto <D.26933>; else goto <D.26934>;
      <D.26933>:
      D.26937 = ctx->verifiable;
      if (D.26937 != 0) goto <D.26935>; else goto <D.26938>;
      <D.26938>:
      D.26927 = ctx->level;
      D.26939 = D.26927 & 128;
      if (D.26939 != 0) goto <D.26935>; else goto <D.26936>;
      <D.26935>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 8;
        D.26918 = ctx->ip_offset;
        D.26940 = monoeg_g_strdup_printf ("Type at stack is not accessible at 0x%04x", D.26918);
        vinfo->info.message = D.26940;
        vinfo->exception_type = 10;
        D.26920 = ctx->list;
        D.26941 = monoeg_g_slist_prepend (D.26920, vinfo);
        ctx->list = D.26941;
      }
      ctx->verifiable = 0;
      D.26927 = ctx->level;
      D.26942 = D.26927 & 16;
      if (D.26942 != 0) goto <D.26943>; else goto <D.26944>;
      <D.26943>:
      ctx->valid = 0;
      <D.26944>:
      <D.26936>:
      <D.26934>:
      <D.26930>:
      D.26912 = field->type;
      D.26945 = verify_stack_type_compatibility (ctx, D.26912, value);
      if (D.26945 == 0) goto <D.26946>; else goto <D.26947>;
      <D.26946>:
      {
        char * stack_name;
        char * field_name;

        stack_name = stack_slot_full_name (value);
        D.26912 = field->type;
        field_name = mono_type_full_name (D.26912);
        D.26937 = ctx->verifiable;
        if (D.26937 != 0) goto <D.26948>; else goto <D.26950>;
        <D.26950>:
        D.26927 = ctx->level;
        D.26939 = D.26927 & 128;
        if (D.26939 != 0) goto <D.26948>; else goto <D.26949>;
        <D.26948>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 8;
          D.26918 = ctx->ip_offset;
          D.26951 = monoeg_g_strdup_printf ("Incompatible type in static field store expected \'%s\' but found \'%s\' at 0x%04x", field_name, stack_name, D.26918);
          vinfo->info.message = D.26951;
          vinfo->exception_type = 4;
          D.26920 = ctx->list;
          D.26952 = monoeg_g_slist_prepend (D.26920, vinfo);
          ctx->list = D.26952;
        }
        ctx->verifiable = 0;
        D.26927 = ctx->level;
        D.26942 = D.26927 & 16;
        if (D.26942 != 0) goto <D.26953>; else goto <D.26954>;
        <D.26953>:
        ctx->valid = 0;
        <D.26954>:
        <D.26949>:
        monoeg_g_free (field_name);
        monoeg_g_free (stack_name);
      }
      <D.26947>:
    }
  finally
    {
      klass = {CLOBBER};
    }
}


do_stobj (struct VerifyContext * ctx, int token)
{
  unsigned int D.26958;
  unsigned int D.26959;
  int D.26962;
  int D.26965;
  int D.26970;
  int D.26972;
  int D.26973;
  unsigned int D.26974;
  gchar * D.26975;
  struct GSList * D.26976;
  struct GSList * D.26977;
  int D.26978;
  int D.26981;
  gchar * D.26987;
  struct GSList * D.26988;
  int D.26991;
  struct MonoType * D.26994;
  int D.26995;
  int D.26998;
  gchar * D.27004;
  struct GSList * D.27005;
  int D.27008;
  gchar * D.27014;
  struct GSList * D.27015;
  struct MonoType * D.27018;
  struct MonoType * D.27019;
  int D.27020;
  gchar * D.27026;
  struct GSList * D.27027;
  struct ILStackDesc * dest;
  struct ILStackDesc * src;
  struct MonoType * type;

  type = get_boxable_mono_type (ctx, token, "stobj");
  D.26958 = ctx->prefix_set;
  D.26959 = D.26958 & 4294967292;
  ctx->prefix_set = D.26959;
  if (type == 0B) goto <D.26960>; else goto <D.26961>;
  <D.26960>:
  return;
  <D.26961>:
  D.26962 = check_underflow (ctx, 2);
  if (D.26962 == 0) goto <D.26963>; else goto <D.26964>;
  <D.26963>:
  return;
  <D.26964>:
  src = stack_pop (ctx);
  dest = stack_pop (ctx);
  D.26965 = stack_slot_is_managed_mutability_pointer (dest);
  if (D.26965 != 0) goto <D.26966>; else goto <D.26967>;
  <D.26966>:
  D.26970 = ctx->verifiable;
  if (D.26970 != 0) goto <D.26968>; else goto <D.26971>;
  <D.26971>:
  D.26972 = ctx->level;
  D.26973 = D.26972 & 128;
  if (D.26973 != 0) goto <D.26968>; else goto <D.26969>;
  <D.26968>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26974 = ctx->ip_offset;
    D.26975 = monoeg_g_strdup_printf ("Cannot use a readonly pointer with stobj at 0x%04x", D.26974);
    vinfo->info.message = D.26975;
    vinfo->exception_type = 4;
    D.26976 = ctx->list;
    D.26977 = monoeg_g_slist_prepend (D.26976, vinfo);
    ctx->list = D.26977;
  }
  ctx->verifiable = 0;
  D.26972 = ctx->level;
  D.26978 = D.26972 & 16;
  if (D.26978 != 0) goto <D.26979>; else goto <D.26980>;
  <D.26979>:
  ctx->valid = 0;
  <D.26980>:
  <D.26969>:
  <D.26967>:
  D.26981 = stack_slot_is_managed_pointer (dest);
  if (D.26981 == 0) goto <D.26982>; else goto <D.26983>;
  <D.26982>:
  D.26970 = ctx->verifiable;
  if (D.26970 != 0) goto <D.26984>; else goto <D.26986>;
  <D.26986>:
  D.26972 = ctx->level;
  D.26973 = D.26972 & 128;
  if (D.26973 != 0) goto <D.26984>; else goto <D.26985>;
  <D.26984>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26974 = ctx->ip_offset;
    D.26987 = monoeg_g_strdup_printf ("Invalid destination of stobj operation at 0x%04x", D.26974);
    vinfo->info.message = D.26987;
    vinfo->exception_type = 4;
    D.26976 = ctx->list;
    D.26988 = monoeg_g_slist_prepend (D.26976, vinfo);
    ctx->list = D.26988;
  }
  ctx->verifiable = 0;
  D.26972 = ctx->level;
  D.26978 = D.26972 & 16;
  if (D.26978 != 0) goto <D.26989>; else goto <D.26990>;
  <D.26989>:
  ctx->valid = 0;
  <D.26990>:
  <D.26985>:
  <D.26983>:
  D.26991 = stack_slot_is_boxed_value (src);
  if (D.26991 != 0) goto <D.26992>; else goto <D.26993>;
  <D.26992>:
  D.26994 = src->type;
  D.26995 = mono_type_is_reference (D.26994);
  if (D.26995 == 0) goto <D.26996>; else goto <D.26997>;
  <D.26996>:
  D.26998 = mono_type_is_reference (type);
  if (D.26998 == 0) goto <D.26999>; else goto <D.27000>;
  <D.26999>:
  D.26970 = ctx->verifiable;
  if (D.26970 != 0) goto <D.27001>; else goto <D.27003>;
  <D.27003>:
  D.26972 = ctx->level;
  D.26973 = D.26972 & 128;
  if (D.26973 != 0) goto <D.27001>; else goto <D.27002>;
  <D.27001>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26974 = ctx->ip_offset;
    D.27004 = monoeg_g_strdup_printf ("Cannot use stobj with a boxed source value that is not a reference type at 0x%04x", D.26974);
    vinfo->info.message = D.27004;
    vinfo->exception_type = 4;
    D.26976 = ctx->list;
    D.27005 = monoeg_g_slist_prepend (D.26976, vinfo);
    ctx->list = D.27005;
  }
  ctx->verifiable = 0;
  D.26972 = ctx->level;
  D.26978 = D.26972 & 16;
  if (D.26978 != 0) goto <D.27006>; else goto <D.27007>;
  <D.27006>:
  ctx->valid = 0;
  <D.27007>:
  <D.27002>:
  <D.27000>:
  <D.26997>:
  <D.26993>:
  D.27008 = verify_stack_type_compatibility (ctx, type, src);
  if (D.27008 == 0) goto <D.27009>; else goto <D.27010>;
  <D.27009>:
  {
    char * type_name;
    char * src_name;

    type_name = mono_type_full_name (type);
    src_name = stack_slot_full_name (src);
    D.26970 = ctx->verifiable;
    if (D.26970 != 0) goto <D.27011>; else goto <D.27013>;
    <D.27013>:
    D.26972 = ctx->level;
    D.26973 = D.26972 & 128;
    if (D.26973 != 0) goto <D.27011>; else goto <D.27012>;
    <D.27011>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 8;
      D.26974 = ctx->ip_offset;
      D.27014 = monoeg_g_strdup_printf ("Token \'%s\' and source \'%s\' of stobj don\'t match \' at 0x%04x", type_name, src_name, D.26974);
      vinfo->info.message = D.27014;
      vinfo->exception_type = 4;
      D.26976 = ctx->list;
      D.27015 = monoeg_g_slist_prepend (D.26976, vinfo);
      ctx->list = D.27015;
    }
    ctx->verifiable = 0;
    D.26972 = ctx->level;
    D.26978 = D.26972 & 16;
    if (D.26978 != 0) goto <D.27016>; else goto <D.27017>;
    <D.27016>:
    ctx->valid = 0;
    <D.27017>:
    <D.27012>:
    monoeg_g_free (type_name);
    monoeg_g_free (src_name);
  }
  <D.27010>:
  D.27018 = dest->type;
  D.27019 = mono_type_get_type_byval (D.27018);
  D.27020 = verify_type_compatibility (ctx, D.27019, type);
  if (D.27020 == 0) goto <D.27021>; else goto <D.27022>;
  <D.27021>:
  D.26970 = ctx->verifiable;
  if (D.26970 != 0) goto <D.27023>; else goto <D.27025>;
  <D.27025>:
  D.26972 = ctx->level;
  D.26973 = D.26972 & 128;
  if (D.26973 != 0) goto <D.27023>; else goto <D.27024>;
  <D.27023>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.26974 = ctx->ip_offset;
    D.27026 = monoeg_g_strdup_printf ("Destination and token types of stobj don\'t match at 0x%04x", D.26974);
    vinfo->info.message = D.27026;
    vinfo->exception_type = 4;
    D.26976 = ctx->list;
    D.27027 = monoeg_g_slist_prepend (D.26976, vinfo);
    ctx->list = D.27027;
  }
  ctx->verifiable = 0;
  D.26972 = ctx->level;
  D.26978 = D.26972 & 16;
  if (D.26978 != 0) goto <D.27028>; else goto <D.27029>;
  <D.27028>:
  ctx->valid = 0;
  <D.27029>:
  <D.27024>:
  <D.27022>:
}


do_box_value (struct VerifyContext * ctx, int klass_token)
{
  int D.27033;
  int D.27036;
  struct MonoType * D.27039;
  int D.27040;
  int D.27043;
  struct ILStackDesc * D.27046;
  int D.27047;
  int D.27048;
  int D.27049;
  int D.27054;
  int D.27056;
  int D.27057;
  unsigned int D.27058;
  gchar * D.27059;
  struct GSList * D.27060;
  struct GSList * D.27061;
  int D.27062;
  int D.27065;
  struct MonoClass * D.27068;
  struct ILStackDesc * value;
  struct MonoType * type;
  struct MonoClass * klass;

  type = get_boxable_mono_type (ctx, klass_token, "box");
  if (type == 0B) goto <D.27031>; else goto <D.27032>;
  <D.27031>:
  return;
  <D.27032>:
  D.27033 = check_underflow (ctx, 1);
  if (D.27033 == 0) goto <D.27034>; else goto <D.27035>;
  <D.27034>:
  return;
  <D.27035>:
  value = stack_pop (ctx);
  D.27036 = stack_slot_get_underlying_type (value);
  if (D.27036 == 6) goto <D.27037>; else goto <D.27038>;
  <D.27037>:
  D.27039 = value->type;
  D.27040 = mono_type_is_reference (D.27039);
  if (D.27040 != 0) goto <D.27041>; else goto <D.27042>;
  <D.27041>:
  D.27043 = mono_type_is_reference (type);
  if (D.27043 != 0) goto <D.27044>; else goto <D.27045>;
  <D.27044>:
  D.27046 = stack_push_stack_val (ctx, value);
  D.27047 = D.27046->stype;
  D.27048 = D.27047 | 4096;
  D.27046->stype = D.27048;
  return;
  <D.27045>:
  <D.27042>:
  <D.27038>:
  D.27049 = verify_stack_type_compatibility (ctx, type, value);
  if (D.27049 == 0) goto <D.27050>; else goto <D.27051>;
  <D.27050>:
  D.27054 = ctx->verifiable;
  if (D.27054 != 0) goto <D.27052>; else goto <D.27055>;
  <D.27055>:
  D.27056 = ctx->level;
  D.27057 = D.27056 & 128;
  if (D.27057 != 0) goto <D.27052>; else goto <D.27053>;
  <D.27052>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27058 = ctx->ip_offset;
    D.27059 = monoeg_g_strdup_printf ("Invalid type at stack for boxing operation at 0x%04x", D.27058);
    vinfo->info.message = D.27059;
    vinfo->exception_type = 4;
    D.27060 = ctx->list;
    D.27061 = monoeg_g_slist_prepend (D.27060, vinfo);
    ctx->list = D.27061;
  }
  ctx->verifiable = 0;
  D.27056 = ctx->level;
  D.27062 = D.27056 & 16;
  if (D.27062 != 0) goto <D.27063>; else goto <D.27064>;
  <D.27063>:
  ctx->valid = 0;
  <D.27064>:
  <D.27053>:
  <D.27051>:
  klass = mono_class_from_mono_type (type);
  D.27065 = mono_class_is_nullable (klass);
  if (D.27065 != 0) goto <D.27066>; else goto <D.27067>;
  <D.27066>:
  D.27068 = mono_class_get_nullable_param (klass);
  type = &D.27068->byval_arg;
  <D.27067>:
  stack_push_val (ctx, 4102, type);
}


do_newarr (struct VerifyContext * ctx, int token)
{
  int D.27072;
  int D.27075;
  int D.27078;
  int D.27083;
  int D.27085;
  int D.27086;
  const char * D.27087;
  unsigned int D.27088;
  gchar * D.27089;
  struct GSList * D.27090;
  struct GSList * D.27091;
  int D.27092;
  struct ILStackDesc * D.27095;
  struct MonoClass * D.27096;
  struct MonoClass * D.27097;
  struct MonoType * D.27098;
  struct ILStackDesc * value;
  struct MonoType * type;

  type = get_boxable_mono_type (ctx, token, "newarr");
  if (type == 0B) goto <D.27070>; else goto <D.27071>;
  <D.27070>:
  return;
  <D.27071>:
  D.27072 = check_underflow (ctx, 1);
  if (D.27072 == 0) goto <D.27073>; else goto <D.27074>;
  <D.27073>:
  return;
  <D.27074>:
  value = stack_pop (ctx);
  D.27075 = stack_slot_get_type (value);
  if (D.27075 != 1) goto <D.27076>; else goto <D.27077>;
  <D.27076>:
  D.27078 = stack_slot_get_type (value);
  if (D.27078 != 3) goto <D.27079>; else goto <D.27080>;
  <D.27079>:
  D.27083 = ctx->verifiable;
  if (D.27083 != 0) goto <D.27081>; else goto <D.27084>;
  <D.27084>:
  D.27085 = ctx->level;
  D.27086 = D.27085 & 128;
  if (D.27086 != 0) goto <D.27081>; else goto <D.27082>;
  <D.27081>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27087 = stack_slot_get_name (value);
    D.27088 = ctx->ip_offset;
    D.27089 = monoeg_g_strdup_printf ("Array size type on stack (%s) is not a verifiable type at 0x%04x", D.27087, D.27088);
    vinfo->info.message = D.27089;
    vinfo->exception_type = 4;
    D.27090 = ctx->list;
    D.27091 = monoeg_g_slist_prepend (D.27090, vinfo);
    ctx->list = D.27091;
  }
  ctx->verifiable = 0;
  D.27085 = ctx->level;
  D.27092 = D.27085 & 16;
  if (D.27092 != 0) goto <D.27093>; else goto <D.27094>;
  <D.27093>:
  ctx->valid = 0;
  <D.27094>:
  <D.27082>:
  <D.27080>:
  <D.27077>:
  D.27095 = stack_push (ctx);
  D.27096 = mono_class_from_mono_type (type);
  D.27097 = mono_array_class_get (D.27096, 1);
  D.27098 = mono_class_get_type (D.27097);
  set_stack_value (ctx, D.27095, D.27098, 0);
}


do_ldlen (struct VerifyContext * ctx)
{
  int D.27100;
  int D.27105;
  struct MonoType * D.27107;
  unsigned char D.27108;
  int D.27111;
  int D.27113;
  int D.27114;
  unsigned int D.27115;
  gchar * D.27116;
  struct GSList * D.27117;
  struct GSList * D.27118;
  int D.27119;
  struct MonoClass * D.27122;
  struct MonoType * D.27123;
  struct ILStackDesc * value;

  D.27100 = check_underflow (ctx, 1);
  if (D.27100 == 0) goto <D.27101>; else goto <D.27102>;
  <D.27101>:
  return;
  <D.27102>:
  value = stack_pop (ctx);
  D.27105 = stack_slot_get_type (value);
  if (D.27105 != 6) goto <D.27103>; else goto <D.27106>;
  <D.27106>:
  D.27107 = value->type;
  D.27108 = D.27107->type;
  if (D.27108 != 29) goto <D.27103>; else goto <D.27104>;
  <D.27103>:
  D.27111 = ctx->verifiable;
  if (D.27111 != 0) goto <D.27109>; else goto <D.27112>;
  <D.27112>:
  D.27113 = ctx->level;
  D.27114 = D.27113 & 128;
  if (D.27114 != 0) goto <D.27109>; else goto <D.27110>;
  <D.27109>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27115 = ctx->ip_offset;
    D.27116 = monoeg_g_strdup_printf ("Invalid array type for ldlen at 0x%04x", D.27115);
    vinfo->info.message = D.27116;
    vinfo->exception_type = 4;
    D.27117 = ctx->list;
    D.27118 = monoeg_g_slist_prepend (D.27117, vinfo);
    ctx->list = D.27118;
  }
  ctx->verifiable = 0;
  D.27113 = ctx->level;
  D.27119 = D.27113 & 16;
  if (D.27119 != 0) goto <D.27120>; else goto <D.27121>;
  <D.27120>:
  ctx->valid = 0;
  <D.27121>:
  <D.27110>:
  <D.27104>:
  D.27122 = mono_defaults.int_class;
  D.27123 = &D.27122->byval_arg;
  stack_push_val (ctx, 3, D.27123);
}


do_ldelema (struct VerifyContext * ctx, int klass_token)
{
  int D.27127;
  int D.27130;
  int D.27133;
  int D.27138;
  int D.27140;
  int D.27141;
  const char * D.27142;
  unsigned int D.27143;
  gchar * D.27144;
  struct GSList * D.27145;
  struct GSList * D.27146;
  int D.27147;
  int D.27150;
  int D.27156;
  struct MonoType * D.27158;
  unsigned char D.27159;
  const char * D.27163;
  gchar * D.27164;
  struct GSList * D.27165;
  int D.27171;
  int D.27173;
  struct MonoClass * D.27174;
  struct MonoType * D.27175;
  gchar * D.27181;
  struct GSList * D.27182;
  unsigned int D.27185;
  unsigned int D.27186;
  unsigned int D.27189;
  int D.27190;
  int D.27191;
  struct ILStackDesc * index;
  struct ILStackDesc * array;
  struct ILStackDesc * res;
  struct MonoType * type;
  gboolean valid;

  type = get_boxable_mono_type (ctx, klass_token, "ldelema");
  if (type == 0B) goto <D.27125>; else goto <D.27126>;
  <D.27125>:
  return;
  <D.27126>:
  D.27127 = check_underflow (ctx, 2);
  if (D.27127 == 0) goto <D.27128>; else goto <D.27129>;
  <D.27128>:
  return;
  <D.27129>:
  index = stack_pop (ctx);
  array = stack_pop (ctx);
  D.27130 = stack_slot_get_type (index);
  if (D.27130 != 1) goto <D.27131>; else goto <D.27132>;
  <D.27131>:
  D.27133 = stack_slot_get_type (index);
  if (D.27133 != 3) goto <D.27134>; else goto <D.27135>;
  <D.27134>:
  D.27138 = ctx->verifiable;
  if (D.27138 != 0) goto <D.27136>; else goto <D.27139>;
  <D.27139>:
  D.27140 = ctx->level;
  D.27141 = D.27140 & 128;
  if (D.27141 != 0) goto <D.27136>; else goto <D.27137>;
  <D.27136>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27142 = stack_slot_get_name (index);
    D.27143 = ctx->ip_offset;
    D.27144 = monoeg_g_strdup_printf ("Index type(%s) for ldelema is not an int or a native int at 0x%04x", D.27142, D.27143);
    vinfo->info.message = D.27144;
    vinfo->exception_type = 4;
    D.27145 = ctx->list;
    D.27146 = monoeg_g_slist_prepend (D.27145, vinfo);
    ctx->list = D.27146;
  }
  ctx->verifiable = 0;
  D.27140 = ctx->level;
  D.27147 = D.27140 & 16;
  if (D.27147 != 0) goto <D.27148>; else goto <D.27149>;
  <D.27148>:
  ctx->valid = 0;
  <D.27149>:
  <D.27137>:
  <D.27135>:
  <D.27132>:
  D.27150 = stack_slot_is_null_literal (array);
  if (D.27150 == 0) goto <D.27151>; else goto <D.27152>;
  <D.27151>:
  D.27156 = stack_slot_get_type (array);
  if (D.27156 != 6) goto <D.27153>; else goto <D.27157>;
  <D.27157>:
  D.27158 = array->type;
  D.27159 = D.27158->type;
  if (D.27159 != 29) goto <D.27153>; else goto <D.27154>;
  <D.27153>:
  D.27138 = ctx->verifiable;
  if (D.27138 != 0) goto <D.27160>; else goto <D.27162>;
  <D.27162>:
  D.27140 = ctx->level;
  D.27141 = D.27140 & 128;
  if (D.27141 != 0) goto <D.27160>; else goto <D.27161>;
  <D.27160>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27163 = stack_slot_get_name (array);
    D.27143 = ctx->ip_offset;
    D.27164 = monoeg_g_strdup_printf ("Invalid array type(%s) for ldelema at 0x%04x", D.27163, D.27143);
    vinfo->info.message = D.27164;
    vinfo->exception_type = 4;
    D.27145 = ctx->list;
    D.27165 = monoeg_g_slist_prepend (D.27145, vinfo);
    ctx->list = D.27165;
  }
  ctx->verifiable = 0;
  D.27140 = ctx->level;
  D.27147 = D.27140 & 16;
  if (D.27147 != 0) goto <D.27166>; else goto <D.27167>;
  <D.27166>:
  ctx->valid = 0;
  <D.27167>:
  <D.27161>:
  goto <D.27155>;
  <D.27154>:
  D.27171 = get_stack_type (type);
  if (D.27171 == 1) goto <D.27168>; else goto <D.27172>;
  <D.27172>:
  D.27173 = get_stack_type (type);
  if (D.27173 == 3) goto <D.27168>; else goto <D.27169>;
  <D.27168>:
  D.27158 = array->type;
  D.27174 = D.27158->data.klass;
  D.27175 = &D.27174->byval_arg;
  valid = verify_type_compatibility_full (ctx, type, D.27175, 1);
  goto <D.27170>;
  <D.27169>:
  D.27158 = array->type;
  D.27174 = D.27158->data.klass;
  D.27175 = &D.27174->byval_arg;
  valid = mono_metadata_type_equal (type, D.27175);
  <D.27170>:
  if (valid == 0) goto <D.27176>; else goto <D.27177>;
  <D.27176>:
  D.27138 = ctx->verifiable;
  if (D.27138 != 0) goto <D.27178>; else goto <D.27180>;
  <D.27180>:
  D.27140 = ctx->level;
  D.27141 = D.27140 & 128;
  if (D.27141 != 0) goto <D.27178>; else goto <D.27179>;
  <D.27178>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27143 = ctx->ip_offset;
    D.27181 = monoeg_g_strdup_printf ("Invalid array type on stack for ldelema at 0x%04x", D.27143);
    vinfo->info.message = D.27181;
    vinfo->exception_type = 4;
    D.27145 = ctx->list;
    D.27182 = monoeg_g_slist_prepend (D.27145, vinfo);
    ctx->list = D.27182;
  }
  ctx->verifiable = 0;
  D.27140 = ctx->level;
  D.27147 = D.27140 & 16;
  if (D.27147 != 0) goto <D.27183>; else goto <D.27184>;
  <D.27183>:
  ctx->valid = 0;
  <D.27184>:
  <D.27179>:
  <D.27177>:
  <D.27155>:
  <D.27152>:
  res = stack_push (ctx);
  set_stack_value (ctx, res, type, 1);
  D.27185 = ctx->prefix_set;
  D.27186 = D.27185 & 16;
  if (D.27186 != 0) goto <D.27187>; else goto <D.27188>;
  <D.27187>:
  D.27185 = ctx->prefix_set;
  D.27189 = D.27185 & 4294967279;
  ctx->prefix_set = D.27189;
  D.27190 = res->stype;
  D.27191 = D.27190 | 512;
  res->stype = D.27191;
  <D.27188>:
}


do_ldelem (struct VerifyContext * ctx, int opcode, int token)
{
  int D.27193;
  unsigned int D.27200;
  gchar * D.27201;
  struct GSList * D.27202;
  struct GSList * D.27203;
  int D.27205;
  int D.27208;
  int D.27213;
  int D.27215;
  int D.27216;
  const char * D.27217;
  gchar * D.27218;
  struct GSList * D.27219;
  int D.27220;
  int D.27223;
  int D.27229;
  struct MonoType * D.27231;
  unsigned char D.27232;
  const char * D.27236;
  gchar * D.27237;
  struct GSList * D.27238;
  struct MonoClass * D.27243;
  unsigned char D.27244;
  unsigned char D.27245;
  gchar * D.27251;
  struct GSList * D.27252;
  int D.27256;
  unsigned char D.27262;
  unsigned char D.27263;
  unsigned char D.27265;
  unsigned char D.27266;
  unsigned char D.27267;
  unsigned char D.27269;
  gchar * D.27273;
  struct GSList * D.27274;
  int D.27277;
  gchar * D.27283;
  struct GSList * D.27284;
  struct ILStackDesc * D.27287;
  struct ILStackDesc * index;
  struct ILStackDesc * array;
  struct MonoType * type;

  D.27193 = check_underflow (ctx, 2);
  if (D.27193 == 0) goto <D.27194>; else goto <D.27195>;
  <D.27194>:
  return;
  <D.27195>:
  if (opcode == 163) goto <D.27196>; else goto <D.27197>;
  <D.27196>:
  type = verifier_load_type (ctx, token, "ldelem.any");
  if (type == 0B) goto <D.27198>; else goto <D.27199>;
  <D.27198>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.27200 = ctx->ip_offset;
    D.27201 = monoeg_g_strdup_printf ("Type (0x%08x) not found at 0x%04x", token, D.27200);
    vinfo->info.message = D.27201;
    vinfo->exception_type = 3;
    D.27202 = ctx->list;
    D.27203 = monoeg_g_slist_prepend (D.27202, vinfo);
    ctx->list = D.27203;
  }
  ctx->valid = 0;
  return;
  <D.27199>:
  goto <D.27204>;
  <D.27197>:
  type = mono_type_from_opcode (opcode);
  <D.27204>:
  index = stack_pop (ctx);
  array = stack_pop (ctx);
  D.27205 = stack_slot_get_type (index);
  if (D.27205 != 1) goto <D.27206>; else goto <D.27207>;
  <D.27206>:
  D.27208 = stack_slot_get_type (index);
  if (D.27208 != 3) goto <D.27209>; else goto <D.27210>;
  <D.27209>:
  D.27213 = ctx->verifiable;
  if (D.27213 != 0) goto <D.27211>; else goto <D.27214>;
  <D.27214>:
  D.27215 = ctx->level;
  D.27216 = D.27215 & 128;
  if (D.27216 != 0) goto <D.27211>; else goto <D.27212>;
  <D.27211>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27217 = stack_slot_get_name (index);
    D.27200 = ctx->ip_offset;
    D.27218 = monoeg_g_strdup_printf ("Index type(%s) for ldelem.X is not an int or a native int at 0x%04x", D.27217, D.27200);
    vinfo->info.message = D.27218;
    vinfo->exception_type = 4;
    D.27202 = ctx->list;
    D.27219 = monoeg_g_slist_prepend (D.27202, vinfo);
    ctx->list = D.27219;
  }
  ctx->verifiable = 0;
  D.27215 = ctx->level;
  D.27220 = D.27215 & 16;
  if (D.27220 != 0) goto <D.27221>; else goto <D.27222>;
  <D.27221>:
  ctx->valid = 0;
  <D.27222>:
  <D.27212>:
  <D.27210>:
  <D.27207>:
  D.27223 = stack_slot_is_null_literal (array);
  if (D.27223 == 0) goto <D.27224>; else goto <D.27225>;
  <D.27224>:
  D.27229 = stack_slot_get_type (array);
  if (D.27229 != 6) goto <D.27226>; else goto <D.27230>;
  <D.27230>:
  D.27231 = array->type;
  D.27232 = D.27231->type;
  if (D.27232 != 29) goto <D.27226>; else goto <D.27227>;
  <D.27226>:
  D.27213 = ctx->verifiable;
  if (D.27213 != 0) goto <D.27233>; else goto <D.27235>;
  <D.27235>:
  D.27215 = ctx->level;
  D.27216 = D.27215 & 128;
  if (D.27216 != 0) goto <D.27233>; else goto <D.27234>;
  <D.27233>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27236 = stack_slot_get_name (array);
    D.27200 = ctx->ip_offset;
    D.27237 = monoeg_g_strdup_printf ("Invalid array type(%s) for ldelem.X at 0x%04x", D.27236, D.27200);
    vinfo->info.message = D.27237;
    vinfo->exception_type = 4;
    D.27202 = ctx->list;
    D.27238 = monoeg_g_slist_prepend (D.27202, vinfo);
    ctx->list = D.27238;
  }
  ctx->verifiable = 0;
  D.27215 = ctx->level;
  D.27220 = D.27215 & 16;
  if (D.27220 != 0) goto <D.27239>; else goto <D.27240>;
  <D.27239>:
  ctx->valid = 0;
  <D.27240>:
  <D.27234>:
  goto <D.27228>;
  <D.27227>:
  if (opcode == 154) goto <D.27241>; else goto <D.27242>;
  <D.27241>:
  D.27231 = array->type;
  D.27243 = D.27231->data.klass;
  D.27244 = BIT_FIELD_REF <*D.27243, 8, 160>;
  D.27245 = D.27244 & 8;
  if (D.27245 != 0) goto <D.27246>; else goto <D.27247>;
  <D.27246>:
  D.27213 = ctx->verifiable;
  if (D.27213 != 0) goto <D.27248>; else goto <D.27250>;
  <D.27250>:
  D.27215 = ctx->level;
  D.27216 = D.27215 & 128;
  if (D.27216 != 0) goto <D.27248>; else goto <D.27249>;
  <D.27248>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27200 = ctx->ip_offset;
    D.27251 = monoeg_g_strdup_printf ("Invalid array type is not a reference type for ldelem.ref 0x%04x", D.27200);
    vinfo->info.message = D.27251;
    vinfo->exception_type = 4;
    D.27202 = ctx->list;
    D.27252 = monoeg_g_slist_prepend (D.27202, vinfo);
    ctx->list = D.27252;
  }
  ctx->verifiable = 0;
  D.27215 = ctx->level;
  D.27220 = D.27215 & 16;
  if (D.27220 != 0) goto <D.27253>; else goto <D.27254>;
  <D.27253>:
  ctx->valid = 0;
  <D.27254>:
  <D.27249>:
  <D.27247>:
  D.27231 = array->type;
  D.27243 = D.27231->data.klass;
  type = &D.27243->byval_arg;
  goto <D.27255>;
  <D.27242>:
  {
    struct MonoType * candidate;

    D.27231 = array->type;
    D.27243 = D.27231->data.klass;
    candidate = &D.27243->byval_arg;
    D.27215 = ctx->level;
    D.27256 = D.27215 & 32;
    if (D.27256 == 0) goto <D.27257>; else goto <D.27258>;
    <D.27257>:
    {
      struct MonoType * underlying_type;
      struct MonoType * underlying_candidate;

      underlying_type = mono_type_get_underlying_type_any (type);
      underlying_candidate = mono_type_get_underlying_type_any (candidate);
      D.27262 = underlying_type->type;
      D.27263 = D.27262 + 248;
      if (D.27263 <= 1) goto <D.27264>; else goto <D.27259>;
      <D.27264>:
      D.27265 = underlying_candidate->type;
      D.27266 = D.27265 + 232;
      if (D.27266 <= 1) goto <D.27260>; else goto <D.27259>;
      <D.27259>:
      D.27265 = underlying_candidate->type;
      D.27267 = D.27265 + 248;
      if (D.27267 <= 1) goto <D.27268>; else goto <D.27261>;
      <D.27268>:
      D.27262 = underlying_type->type;
      D.27269 = D.27262 + 232;
      if (D.27269 <= 1) goto <D.27260>; else goto <D.27261>;
      <D.27260>:
      D.27213 = ctx->verifiable;
      if (D.27213 != 0) goto <D.27270>; else goto <D.27272>;
      <D.27272>:
      D.27215 = ctx->level;
      D.27216 = D.27215 & 128;
      if (D.27216 != 0) goto <D.27270>; else goto <D.27271>;
      <D.27270>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 8;
        D.27200 = ctx->ip_offset;
        D.27273 = monoeg_g_strdup_printf ("Invalid array type on stack for ldelem.X at 0x%04x", D.27200);
        vinfo->info.message = D.27273;
        vinfo->exception_type = 4;
        D.27202 = ctx->list;
        D.27274 = monoeg_g_slist_prepend (D.27202, vinfo);
        ctx->list = D.27274;
      }
      ctx->verifiable = 0;
      D.27215 = ctx->level;
      D.27220 = D.27215 & 16;
      if (D.27220 != 0) goto <D.27275>; else goto <D.27276>;
      <D.27275>:
      ctx->valid = 0;
      <D.27276>:
      <D.27271>:
      <D.27261>:
    }
    <D.27258>:
    D.27277 = verify_type_compatibility_full (ctx, type, candidate, 1);
    if (D.27277 == 0) goto <D.27278>; else goto <D.27279>;
    <D.27278>:
    D.27213 = ctx->verifiable;
    if (D.27213 != 0) goto <D.27280>; else goto <D.27282>;
    <D.27282>:
    D.27215 = ctx->level;
    D.27216 = D.27215 & 128;
    if (D.27216 != 0) goto <D.27280>; else goto <D.27281>;
    <D.27280>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 8;
      D.27200 = ctx->ip_offset;
      D.27283 = monoeg_g_strdup_printf ("Invalid array type on stack for ldelem.X at 0x%04x", D.27200);
      vinfo->info.message = D.27283;
      vinfo->exception_type = 4;
      D.27202 = ctx->list;
      D.27284 = monoeg_g_slist_prepend (D.27202, vinfo);
      ctx->list = D.27284;
    }
    ctx->verifiable = 0;
    D.27215 = ctx->level;
    D.27220 = D.27215 & 16;
    if (D.27220 != 0) goto <D.27285>; else goto <D.27286>;
    <D.27285>:
    ctx->valid = 0;
    <D.27286>:
    <D.27281>:
    <D.27279>:
  }
  <D.27255>:
  <D.27228>:
  <D.27225>:
  D.27287 = stack_push (ctx);
  set_stack_value (ctx, D.27287, type, 0);
}


verifier_load_type (struct VerifyContext * ctx, int token, const char * opcode)
{
  struct MonoMethod * D.27289;
  unsigned char D.27290;
  unsigned char D.27291;
  unsigned int token.110;
  struct MonoType * iftmp.111;
  int D.27302;
  unsigned int D.27303;
  unsigned int D.27304;
  _Bool D.27305;
  _Bool D.27306;
  _Bool D.27307;
  struct MonoImage * D.27309;
  unsigned int token.112;
  int D.27311;
  unsigned int D.27312;
  gchar * D.27313;
  struct GSList * D.27314;
  struct GSList * D.27315;
  struct MonoType * D.27316;
  struct MonoGenericContext * D.27317;
  struct MonoLoaderError * D.27321;
  gchar * D.27322;
  struct GSList * D.27323;
  int D.27324;
  struct MonoType * type;

  D.27289 = ctx->method;
  D.27290 = BIT_FIELD_REF <*D.27289, 8, 160>;
  D.27291 = D.27290 & 124;
  if (D.27291 != 0) goto <D.27292>; else goto <D.27293>;
  <D.27292>:
  {
    struct MonoClass * class;

    D.27289 = ctx->method;
    token.110 = (unsigned int) token;
    class = mono_method_get_wrapper_data (D.27289, token.110);
    if (class != 0B) goto <D.27296>; else goto <D.27297>;
    <D.27296>:
    iftmp.111 = &class->byval_arg;
    goto <D.27298>;
    <D.27297>:
    iftmp.111 = 0B;
    <D.27298>:
    type = iftmp.111;
  }
  goto <D.27299>;
  <D.27293>:
  D.27302 = token >> 24;
  D.27303 = (unsigned int) D.27302;
  D.27304 = D.27303 + 4294967295;
  D.27305 = D.27304 > 1;
  D.27306 = D.27302 != 27;
  D.27307 = D.27305 & D.27306;
  if (D.27307 != 0) goto <D.27300>; else goto <D.27308>;
  <D.27308>:
  D.27309 = ctx->image;
  token.112 = (unsigned int) token;
  D.27311 = token_bounds_check (D.27309, token.112);
  if (D.27311 == 0) goto <D.27300>; else goto <D.27301>;
  <D.27300>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.27312 = ctx->ip_offset;
    D.27313 = monoeg_g_strdup_printf ("Invalid type token 0x%08x at 0x%04x", token, D.27312);
    vinfo->info.message = D.27313;
    vinfo->exception_type = 12;
    D.27314 = ctx->list;
    D.27315 = monoeg_g_slist_prepend (D.27314, vinfo);
    ctx->list = D.27315;
  }
  ctx->valid = 0;
  D.27316 = 0B;
  return D.27316;
  <D.27301>:
  D.27309 = ctx->image;
  token.112 = (unsigned int) token;
  D.27317 = ctx->generic_context;
  type = mono_type_get_full (D.27309, token.112, D.27317);
  <D.27299>:
  if (type == 0B) goto <D.27318>; else goto <D.27320>;
  <D.27320>:
  D.27321 = mono_loader_get_last_error ();
  if (D.27321 != 0B) goto <D.27318>; else goto <D.27319>;
  <D.27318>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.27312 = ctx->ip_offset;
    D.27322 = monoeg_g_strdup_printf ("Cannot load type from token 0x%08x for %s at 0x%04x", token, opcode, D.27312);
    vinfo->info.message = D.27322;
    vinfo->exception_type = 12;
    D.27314 = ctx->list;
    D.27323 = monoeg_g_slist_prepend (D.27314, vinfo);
    ctx->list = D.27323;
  }
  ctx->valid = 0;
  mono_loader_clear_error ();
  D.27316 = 0B;
  return D.27316;
  <D.27319>:
  D.27324 = mono_type_is_valid_in_context (ctx, type);
  if (D.27324 == 0) goto <D.27325>; else goto <D.27326>;
  <D.27325>:
  D.27316 = 0B;
  return D.27316;
  <D.27326>:
  D.27316 = type;
  return D.27316;
}


do_stelem (struct VerifyContext * ctx, int opcode, int token)
{
  int D.27328;
  unsigned int D.27335;
  gchar * D.27336;
  struct GSList * D.27337;
  struct GSList * D.27338;
  int D.27340;
  int D.27343;
  int D.27348;
  int D.27350;
  int D.27351;
  const char * D.27352;
  gchar * D.27353;
  struct GSList * D.27354;
  int D.27355;
  int D.27358;
  int D.27364;
  struct MonoType * D.27366;
  unsigned char D.27367;
  const char * D.27371;
  gchar * D.27372;
  struct GSList * D.27373;
  struct MonoClass * D.27378;
  unsigned char D.27379;
  unsigned char D.27380;
  gchar * D.27386;
  struct GSList * D.27387;
  struct MonoType * D.27391;
  int D.27392;
  gchar * D.27398;
  struct GSList * D.27399;
  int D.27404;
  struct MonoType * D.27407;
  struct MonoClass * D.27408;
  unsigned char D.27409;
  unsigned char D.27410;
  gchar * D.27416;
  struct GSList * D.27417;
  int D.27423;
  gchar * D.27429;
  struct GSList * D.27430;
  int D.27433;
  int D.27436;
  int D.27439;
  gchar * D.27445;
  struct GSList * D.27446;
  struct ILStackDesc * index;
  struct ILStackDesc * array;
  struct ILStackDesc * value;
  struct MonoType * type;

  D.27328 = check_underflow (ctx, 3);
  if (D.27328 == 0) goto <D.27329>; else goto <D.27330>;
  <D.27329>:
  return;
  <D.27330>:
  if (opcode == 164) goto <D.27331>; else goto <D.27332>;
  <D.27331>:
  type = verifier_load_type (ctx, token, "stelem.any");
  if (type == 0B) goto <D.27333>; else goto <D.27334>;
  <D.27333>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.27335 = ctx->ip_offset;
    D.27336 = monoeg_g_strdup_printf ("Type (0x%08x) not found at 0x%04x", token, D.27335);
    vinfo->info.message = D.27336;
    vinfo->exception_type = 3;
    D.27337 = ctx->list;
    D.27338 = monoeg_g_slist_prepend (D.27337, vinfo);
    ctx->list = D.27338;
  }
  ctx->valid = 0;
  return;
  <D.27334>:
  goto <D.27339>;
  <D.27332>:
  type = mono_type_from_opcode (opcode);
  <D.27339>:
  value = stack_pop (ctx);
  index = stack_pop (ctx);
  array = stack_pop (ctx);
  D.27340 = stack_slot_get_type (index);
  if (D.27340 != 1) goto <D.27341>; else goto <D.27342>;
  <D.27341>:
  D.27343 = stack_slot_get_type (index);
  if (D.27343 != 3) goto <D.27344>; else goto <D.27345>;
  <D.27344>:
  D.27348 = ctx->verifiable;
  if (D.27348 != 0) goto <D.27346>; else goto <D.27349>;
  <D.27349>:
  D.27350 = ctx->level;
  D.27351 = D.27350 & 128;
  if (D.27351 != 0) goto <D.27346>; else goto <D.27347>;
  <D.27346>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27352 = stack_slot_get_name (index);
    D.27335 = ctx->ip_offset;
    D.27353 = monoeg_g_strdup_printf ("Index type(%s) for stdelem.X is not an int or a native int at 0x%04x", D.27352, D.27335);
    vinfo->info.message = D.27353;
    vinfo->exception_type = 4;
    D.27337 = ctx->list;
    D.27354 = monoeg_g_slist_prepend (D.27337, vinfo);
    ctx->list = D.27354;
  }
  ctx->verifiable = 0;
  D.27350 = ctx->level;
  D.27355 = D.27350 & 16;
  if (D.27355 != 0) goto <D.27356>; else goto <D.27357>;
  <D.27356>:
  ctx->valid = 0;
  <D.27357>:
  <D.27347>:
  <D.27345>:
  <D.27342>:
  D.27358 = stack_slot_is_null_literal (array);
  if (D.27358 == 0) goto <D.27359>; else goto <D.27360>;
  <D.27359>:
  D.27364 = stack_slot_get_type (array);
  if (D.27364 != 6) goto <D.27361>; else goto <D.27365>;
  <D.27365>:
  D.27366 = array->type;
  D.27367 = D.27366->type;
  if (D.27367 != 29) goto <D.27361>; else goto <D.27362>;
  <D.27361>:
  D.27348 = ctx->verifiable;
  if (D.27348 != 0) goto <D.27368>; else goto <D.27370>;
  <D.27370>:
  D.27350 = ctx->level;
  D.27351 = D.27350 & 128;
  if (D.27351 != 0) goto <D.27368>; else goto <D.27369>;
  <D.27368>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27371 = stack_slot_get_name (array);
    D.27335 = ctx->ip_offset;
    D.27372 = monoeg_g_strdup_printf ("Invalid array type(%s) for stelem.X at 0x%04x", D.27371, D.27335);
    vinfo->info.message = D.27372;
    vinfo->exception_type = 4;
    D.27337 = ctx->list;
    D.27373 = monoeg_g_slist_prepend (D.27337, vinfo);
    ctx->list = D.27373;
  }
  ctx->verifiable = 0;
  D.27350 = ctx->level;
  D.27355 = D.27350 & 16;
  if (D.27355 != 0) goto <D.27374>; else goto <D.27375>;
  <D.27374>:
  ctx->valid = 0;
  <D.27375>:
  <D.27369>:
  goto <D.27363>;
  <D.27362>:
  if (opcode == 162) goto <D.27376>; else goto <D.27377>;
  <D.27376>:
  D.27366 = array->type;
  D.27378 = D.27366->data.klass;
  D.27379 = BIT_FIELD_REF <*D.27378, 8, 160>;
  D.27380 = D.27379 & 8;
  if (D.27380 != 0) goto <D.27381>; else goto <D.27382>;
  <D.27381>:
  D.27348 = ctx->verifiable;
  if (D.27348 != 0) goto <D.27383>; else goto <D.27385>;
  <D.27385>:
  D.27350 = ctx->level;
  D.27351 = D.27350 & 128;
  if (D.27351 != 0) goto <D.27383>; else goto <D.27384>;
  <D.27383>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27335 = ctx->ip_offset;
    D.27386 = monoeg_g_strdup_printf ("Invalid array type is not a reference type for stelem.ref 0x%04x", D.27335);
    vinfo->info.message = D.27386;
    vinfo->exception_type = 4;
    D.27337 = ctx->list;
    D.27387 = monoeg_g_slist_prepend (D.27337, vinfo);
    ctx->list = D.27387;
  }
  ctx->verifiable = 0;
  D.27350 = ctx->level;
  D.27355 = D.27350 & 16;
  if (D.27355 != 0) goto <D.27388>; else goto <D.27389>;
  <D.27388>:
  ctx->valid = 0;
  <D.27389>:
  <D.27384>:
  <D.27382>:
  goto <D.27390>;
  <D.27377>:
  D.27366 = array->type;
  D.27378 = D.27366->data.klass;
  D.27391 = &D.27378->byval_arg;
  D.27392 = verify_type_compatibility_full (ctx, D.27391, type, 1);
  if (D.27392 == 0) goto <D.27393>; else goto <D.27394>;
  <D.27393>:
  D.27348 = ctx->verifiable;
  if (D.27348 != 0) goto <D.27395>; else goto <D.27397>;
  <D.27397>:
  D.27350 = ctx->level;
  D.27351 = D.27350 & 128;
  if (D.27351 != 0) goto <D.27395>; else goto <D.27396>;
  <D.27395>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27335 = ctx->ip_offset;
    D.27398 = monoeg_g_strdup_printf ("Invalid array type on stack for stdelem.X at 0x%04x", D.27335);
    vinfo->info.message = D.27398;
    vinfo->exception_type = 4;
    D.27337 = ctx->list;
    D.27399 = monoeg_g_slist_prepend (D.27337, vinfo);
    ctx->list = D.27399;
  }
  ctx->verifiable = 0;
  D.27350 = ctx->level;
  D.27355 = D.27350 & 16;
  if (D.27355 != 0) goto <D.27400>; else goto <D.27401>;
  <D.27400>:
  ctx->valid = 0;
  <D.27401>:
  <D.27396>:
  <D.27394>:
  <D.27390>:
  <D.27363>:
  <D.27360>:
  if (opcode == 162) goto <D.27402>; else goto <D.27403>;
  <D.27402>:
  D.27404 = stack_slot_is_boxed_value (value);
  if (D.27404 == 0) goto <D.27405>; else goto <D.27406>;
  <D.27405>:
  D.27407 = value->type;
  D.27408 = mono_class_from_mono_type (D.27407);
  D.27409 = BIT_FIELD_REF <*D.27408, 8, 160>;
  D.27410 = D.27409 & 8;
  if (D.27410 != 0) goto <D.27411>; else goto <D.27412>;
  <D.27411>:
  D.27348 = ctx->verifiable;
  if (D.27348 != 0) goto <D.27413>; else goto <D.27415>;
  <D.27415>:
  D.27350 = ctx->level;
  D.27351 = D.27350 & 128;
  if (D.27351 != 0) goto <D.27413>; else goto <D.27414>;
  <D.27413>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27335 = ctx->ip_offset;
    D.27416 = monoeg_g_strdup_printf ("Invalid value is not a reference type for stelem.ref 0x%04x", D.27335);
    vinfo->info.message = D.27416;
    vinfo->exception_type = 4;
    D.27337 = ctx->list;
    D.27417 = monoeg_g_slist_prepend (D.27337, vinfo);
    ctx->list = D.27417;
  }
  ctx->verifiable = 0;
  D.27350 = ctx->level;
  D.27355 = D.27350 & 16;
  if (D.27355 != 0) goto <D.27418>; else goto <D.27419>;
  <D.27418>:
  ctx->valid = 0;
  <D.27419>:
  <D.27414>:
  <D.27412>:
  <D.27406>:
  goto <D.27420>;
  <D.27403>:
  if (opcode != 162) goto <D.27421>; else goto <D.27422>;
  <D.27421>:
  D.27423 = verify_stack_type_compatibility (ctx, type, value);
  if (D.27423 == 0) goto <D.27424>; else goto <D.27425>;
  <D.27424>:
  D.27348 = ctx->verifiable;
  if (D.27348 != 0) goto <D.27426>; else goto <D.27428>;
  <D.27428>:
  D.27350 = ctx->level;
  D.27351 = D.27350 & 128;
  if (D.27351 != 0) goto <D.27426>; else goto <D.27427>;
  <D.27426>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27335 = ctx->ip_offset;
    D.27429 = monoeg_g_strdup_printf ("Invalid value on stack for stdelem.X at 0x%04x", D.27335);
    vinfo->info.message = D.27429;
    vinfo->exception_type = 4;
    D.27337 = ctx->list;
    D.27430 = monoeg_g_slist_prepend (D.27337, vinfo);
    ctx->list = D.27430;
  }
  ctx->verifiable = 0;
  D.27350 = ctx->level;
  D.27355 = D.27350 & 16;
  if (D.27355 != 0) goto <D.27431>; else goto <D.27432>;
  <D.27431>:
  ctx->valid = 0;
  <D.27432>:
  <D.27427>:
  <D.27425>:
  D.27433 = stack_slot_is_boxed_value (value);
  if (D.27433 != 0) goto <D.27434>; else goto <D.27435>;
  <D.27434>:
  D.27407 = value->type;
  D.27436 = mono_type_is_reference (D.27407);
  if (D.27436 == 0) goto <D.27437>; else goto <D.27438>;
  <D.27437>:
  D.27439 = mono_type_is_reference (type);
  if (D.27439 == 0) goto <D.27440>; else goto <D.27441>;
  <D.27440>:
  D.27348 = ctx->verifiable;
  if (D.27348 != 0) goto <D.27442>; else goto <D.27444>;
  <D.27444>:
  D.27350 = ctx->level;
  D.27351 = D.27350 & 128;
  if (D.27351 != 0) goto <D.27442>; else goto <D.27443>;
  <D.27442>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27335 = ctx->ip_offset;
    D.27445 = monoeg_g_strdup_printf ("Cannot use stobj with a boxed source value that is not a reference type at 0x%04x", D.27335);
    vinfo->info.message = D.27445;
    vinfo->exception_type = 4;
    D.27337 = ctx->list;
    D.27446 = monoeg_g_slist_prepend (D.27337, vinfo);
    ctx->list = D.27446;
  }
  ctx->verifiable = 0;
  D.27350 = ctx->level;
  D.27355 = D.27350 & 16;
  if (D.27355 != 0) goto <D.27447>; else goto <D.27448>;
  <D.27447>:
  ctx->valid = 0;
  <D.27448>:
  <D.27443>:
  <D.27441>:
  <D.27438>:
  <D.27435>:
  <D.27422>:
  <D.27420>:
}


do_unbox_any (struct VerifyContext * ctx, int klass_token)
{
  int D.27452;
  int D.27457;
  int D.27459;
  struct MonoType * D.27461;
  struct MonoClass * D.27462;
  unsigned char D.27463;
  unsigned char D.27464;
  int D.27467;
  int D.27469;
  int D.27470;
  const char * D.27471;
  unsigned int D.27472;
  gchar * D.27473;
  struct GSList * D.27474;
  struct GSList * D.27475;
  int D.27476;
  struct ILStackDesc * D.27479;
  struct ILStackDesc * value;
  struct MonoType * type;

  type = get_boxable_mono_type (ctx, klass_token, "unbox.any");
  if (type == 0B) goto <D.27450>; else goto <D.27451>;
  <D.27450>:
  return;
  <D.27451>:
  D.27452 = check_underflow (ctx, 1);
  if (D.27452 == 0) goto <D.27453>; else goto <D.27454>;
  <D.27453>:
  return;
  <D.27454>:
  value = stack_pop (ctx);
  D.27457 = stack_slot_get_type (value);
  if (D.27457 != 6) goto <D.27455>; else goto <D.27458>;
  <D.27458>:
  D.27459 = stack_slot_is_boxed_value (value);
  if (D.27459 == 0) goto <D.27460>; else goto <D.27456>;
  <D.27460>:
  D.27461 = value->type;
  D.27462 = mono_class_from_mono_type (D.27461);
  D.27463 = BIT_FIELD_REF <*D.27462, 8, 160>;
  D.27464 = D.27463 & 8;
  if (D.27464 != 0) goto <D.27455>; else goto <D.27456>;
  <D.27455>:
  D.27467 = ctx->verifiable;
  if (D.27467 != 0) goto <D.27465>; else goto <D.27468>;
  <D.27468>:
  D.27469 = ctx->level;
  D.27470 = D.27469 & 128;
  if (D.27470 != 0) goto <D.27465>; else goto <D.27466>;
  <D.27465>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27471 = stack_slot_get_name (value);
    D.27472 = ctx->ip_offset;
    D.27473 = monoeg_g_strdup_printf ("Invalid type %s at stack for unbox.any operation at 0x%04x", D.27471, D.27472);
    vinfo->info.message = D.27473;
    vinfo->exception_type = 4;
    D.27474 = ctx->list;
    D.27475 = monoeg_g_slist_prepend (D.27474, vinfo);
    ctx->list = D.27475;
  }
  ctx->verifiable = 0;
  D.27469 = ctx->level;
  D.27476 = D.27469 & 16;
  if (D.27476 != 0) goto <D.27477>; else goto <D.27478>;
  <D.27477>:
  ctx->valid = 0;
  <D.27478>:
  <D.27466>:
  <D.27456>:
  D.27479 = stack_push (ctx);
  set_stack_value (ctx, D.27479, type, 0);
}


do_conversion (struct VerifyContext * ctx, int kind)
{
  int D.27481;
  int D.27484;
  int D.27487;
  int D.27489;
  int D.27490;
  const char * D.27491;
  unsigned int D.27492;
  gchar * D.27493;
  struct GSList * D.27494;
  struct GSList * D.27495;
  int D.27496;
  struct MonoClass * D.27499;
  struct MonoType * D.27500;
  struct MonoClass * D.27501;
  struct MonoType * D.27502;
  struct MonoClass * D.27503;
  struct MonoType * D.27504;
  struct MonoClass * D.27505;
  struct MonoType * D.27506;
  struct ILStackDesc * value;

  D.27481 = check_underflow (ctx, 1);
  if (D.27481 == 0) goto <D.27482>; else goto <D.27483>;
  <D.27482>:
  return;
  <D.27483>:
  value = stack_pop (ctx);
  D.27484 = stack_slot_get_type (value);
  switch (D.27484) <default: <D.21163>, case 1: <D.21158>, case 2: <D.21159>, case 3: <D.21160>, case 4: <D.21161>>
  <D.21158>:
  <D.21159>:
  <D.21160>:
  <D.21161>:
  goto <D.21162>;
  <D.21163>:
  D.27487 = ctx->verifiable;
  if (D.27487 != 0) goto <D.27485>; else goto <D.27488>;
  <D.27488>:
  D.27489 = ctx->level;
  D.27490 = D.27489 & 128;
  if (D.27490 != 0) goto <D.27485>; else goto <D.27486>;
  <D.27485>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27491 = stack_slot_get_name (value);
    D.27492 = ctx->ip_offset;
    D.27493 = monoeg_g_strdup_printf ("Invalid type (%s) at stack for conversion operation. Numeric type expected at 0x%04x", D.27491, D.27492);
    vinfo->info.message = D.27493;
    vinfo->exception_type = 4;
    D.27494 = ctx->list;
    D.27495 = monoeg_g_slist_prepend (D.27494, vinfo);
    ctx->list = D.27495;
  }
  ctx->verifiable = 0;
  D.27489 = ctx->level;
  D.27496 = D.27489 & 16;
  if (D.27496 != 0) goto <D.27497>; else goto <D.27498>;
  <D.27497>:
  ctx->valid = 0;
  <D.27498>:
  <D.27486>:
  <D.21162>:
  switch (kind) <default: <D.21170>, case 1: <D.21165>, case 2: <D.21167>, case 3: <D.21169>, case 4: <D.21168>>
  <D.21165>:
  D.27499 = mono_defaults.int32_class;
  D.27500 = &D.27499->byval_arg;
  stack_push_val (ctx, 1, D.27500);
  goto <D.21166>;
  <D.21167>:
  D.27501 = mono_defaults.int64_class;
  D.27502 = &D.27501->byval_arg;
  stack_push_val (ctx, 2, D.27502);
  goto <D.21166>;
  <D.21168>:
  D.27503 = mono_defaults.double_class;
  D.27504 = &D.27503->byval_arg;
  stack_push_val (ctx, 4, D.27504);
  goto <D.21166>;
  <D.21169>:
  D.27505 = mono_defaults.int_class;
  D.27506 = &D.27505->byval_arg;
  stack_push_val (ctx, 3, D.27506);
  goto <D.21166>;
  <D.21170>:
  monoeg_g_log (0B, 4, "unknown type %02x in conversion", kind);
  <D.21171>:
  goto <D.21171>;
  <D.21166>:
}


do_refanyval (struct VerifyContext * ctx, int token)
{
  int D.27509;
  int D.27516;
  struct MonoType * D.27518;
  unsigned char D.27519;
  const char * D.27520;
  unsigned int D.27521;
  gchar * D.27522;
  struct GSList * D.27523;
  struct GSList * D.27524;
  struct ILStackDesc * D.27525;
  struct ILStackDesc * top;
  struct MonoType * type;

  D.27509 = check_underflow (ctx, 1);
  if (D.27509 == 0) goto <D.27510>; else goto <D.27511>;
  <D.27510>:
  return;
  <D.27511>:
  type = get_boxable_mono_type (ctx, token, "refanyval");
  if (type == 0B) goto <D.27512>; else goto <D.27513>;
  <D.27512>:
  return;
  <D.27513>:
  top = stack_pop (ctx);
  D.27516 = top->stype;
  if (D.27516 != 5) goto <D.27514>; else goto <D.27517>;
  <D.27517>:
  D.27518 = top->type;
  D.27519 = D.27518->type;
  if (D.27519 != 22) goto <D.27514>; else goto <D.27515>;
  <D.27514>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.27520 = stack_slot_get_name (top);
    D.27521 = ctx->ip_offset;
    D.27522 = monoeg_g_strdup_printf ("Expected a typedref as argument for refanyval, but found %s at 0x%04x", D.27520, D.27521);
    vinfo->info.message = D.27522;
    vinfo->exception_type = 3;
    D.27523 = ctx->list;
    D.27524 = monoeg_g_slist_prepend (D.27523, vinfo);
    ctx->list = D.27524;
  }
  ctx->valid = 0;
  <D.27515>:
  D.27525 = stack_push (ctx);
  set_stack_value (ctx, D.27525, type, 1);
}


do_ckfinite (struct VerifyContext * ctx)
{
  int D.27527;
  int D.27530;
  const char * D.27533;
  unsigned int D.27534;
  gchar * D.27535;
  struct GSList * D.27536;
  struct GSList * D.27537;
  struct ILStackDesc * top;

  D.27527 = check_underflow (ctx, 1);
  if (D.27527 == 0) goto <D.27528>; else goto <D.27529>;
  <D.27528>:
  return;
  <D.27529>:
  top = stack_pop (ctx);
  D.27530 = stack_slot_get_underlying_type (top);
  if (D.27530 != 4) goto <D.27531>; else goto <D.27532>;
  <D.27531>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.27533 = stack_slot_get_name (top);
    D.27534 = ctx->ip_offset;
    D.27535 = monoeg_g_strdup_printf ("Expected float32 or float64 on stack for ckfinit but found %s at 0x%04x", D.27533, D.27534);
    vinfo->info.message = D.27535;
    vinfo->exception_type = 3;
    D.27536 = ctx->list;
    D.27537 = monoeg_g_slist_prepend (D.27536, vinfo);
    ctx->list = D.27537;
  }
  ctx->valid = 0;
  <D.27532>:
  stack_push_stack_val (ctx, top);
}


do_mkrefany (struct VerifyContext * ctx, int token)
{
  int D.27539;
  int D.27544;
  int D.27549;
  int D.27551;
  int D.27552;
  unsigned int D.27553;
  gchar * D.27554;
  struct GSList * D.27555;
  struct GSList * D.27556;
  int D.27557;
  int D.27560;
  const char * D.27566;
  gchar * D.27567;
  struct GSList * D.27568;
  struct MonoType * D.27572;
  int D.27573;
  int D.27576;
  gchar * D.27582;
  struct GSList * D.27583;
  int D.27586;
  int D.27589;
  gchar * D.27595;
  struct GSList * D.27596;
  struct ILStackDesc * D.27599;
  struct MonoClass * D.27600;
  struct MonoType * D.27601;
  struct ILStackDesc * top;
  struct MonoType * type;

  D.27539 = check_underflow (ctx, 1);
  if (D.27539 == 0) goto <D.27540>; else goto <D.27541>;
  <D.27540>:
  return;
  <D.27541>:
  type = get_boxable_mono_type (ctx, token, "refanyval");
  if (type == 0B) goto <D.27542>; else goto <D.27543>;
  <D.27542>:
  return;
  <D.27543>:
  top = stack_pop (ctx);
  D.27544 = stack_slot_is_managed_mutability_pointer (top);
  if (D.27544 != 0) goto <D.27545>; else goto <D.27546>;
  <D.27545>:
  D.27549 = ctx->verifiable;
  if (D.27549 != 0) goto <D.27547>; else goto <D.27550>;
  <D.27550>:
  D.27551 = ctx->level;
  D.27552 = D.27551 & 128;
  if (D.27552 != 0) goto <D.27547>; else goto <D.27548>;
  <D.27547>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27553 = ctx->ip_offset;
    D.27554 = monoeg_g_strdup_printf ("Cannot use a readonly pointer with mkrefany at 0x%04x", D.27553);
    vinfo->info.message = D.27554;
    vinfo->exception_type = 4;
    D.27555 = ctx->list;
    D.27556 = monoeg_g_slist_prepend (D.27555, vinfo);
    ctx->list = D.27556;
  }
  ctx->verifiable = 0;
  D.27551 = ctx->level;
  D.27557 = D.27551 & 16;
  if (D.27557 != 0) goto <D.27558>; else goto <D.27559>;
  <D.27558>:
  ctx->valid = 0;
  <D.27559>:
  <D.27548>:
  <D.27546>:
  D.27560 = stack_slot_is_managed_pointer (top);
  if (D.27560 == 0) goto <D.27561>; else goto <D.27562>;
  <D.27561>:
  D.27549 = ctx->verifiable;
  if (D.27549 != 0) goto <D.27563>; else goto <D.27565>;
  <D.27565>:
  D.27551 = ctx->level;
  D.27552 = D.27551 & 128;
  if (D.27552 != 0) goto <D.27563>; else goto <D.27564>;
  <D.27563>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27566 = stack_slot_get_name (top);
    D.27553 = ctx->ip_offset;
    D.27567 = monoeg_g_strdup_printf ("Expected a managed pointer for mkrefany, but found %s at 0x%04x", D.27566, D.27553);
    vinfo->info.message = D.27567;
    vinfo->exception_type = 4;
    D.27555 = ctx->list;
    D.27568 = monoeg_g_slist_prepend (D.27555, vinfo);
    ctx->list = D.27568;
  }
  ctx->verifiable = 0;
  D.27551 = ctx->level;
  D.27557 = D.27551 & 16;
  if (D.27557 != 0) goto <D.27569>; else goto <D.27570>;
  <D.27569>:
  ctx->valid = 0;
  <D.27570>:
  <D.27564>:
  goto <D.27571>;
  <D.27562>:
  {
    struct MonoType * stack_type;

    D.27572 = top->type;
    stack_type = mono_type_get_type_byval (D.27572);
    D.27573 = mono_type_is_reference (type);
    if (D.27573 != 0) goto <D.27574>; else goto <D.27575>;
    <D.27574>:
    D.27576 = mono_metadata_type_equal (type, stack_type);
    if (D.27576 == 0) goto <D.27577>; else goto <D.27578>;
    <D.27577>:
    D.27549 = ctx->verifiable;
    if (D.27549 != 0) goto <D.27579>; else goto <D.27581>;
    <D.27581>:
    D.27551 = ctx->level;
    D.27552 = D.27551 & 128;
    if (D.27552 != 0) goto <D.27579>; else goto <D.27580>;
    <D.27579>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 8;
      D.27553 = ctx->ip_offset;
      D.27582 = monoeg_g_strdup_printf ("Type not compatible for mkrefany at 0x%04x", D.27553);
      vinfo->info.message = D.27582;
      vinfo->exception_type = 4;
      D.27555 = ctx->list;
      D.27583 = monoeg_g_slist_prepend (D.27555, vinfo);
      ctx->list = D.27583;
    }
    ctx->verifiable = 0;
    D.27551 = ctx->level;
    D.27557 = D.27551 & 16;
    if (D.27557 != 0) goto <D.27584>; else goto <D.27585>;
    <D.27584>:
    ctx->valid = 0;
    <D.27585>:
    <D.27580>:
    <D.27578>:
    <D.27575>:
    D.27586 = mono_type_is_reference (type);
    if (D.27586 == 0) goto <D.27587>; else goto <D.27588>;
    <D.27587>:
    D.27589 = verify_type_compatibility_full (ctx, type, stack_type, 1);
    if (D.27589 == 0) goto <D.27590>; else goto <D.27591>;
    <D.27590>:
    D.27549 = ctx->verifiable;
    if (D.27549 != 0) goto <D.27592>; else goto <D.27594>;
    <D.27594>:
    D.27551 = ctx->level;
    D.27552 = D.27551 & 128;
    if (D.27552 != 0) goto <D.27592>; else goto <D.27593>;
    <D.27592>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 8;
      D.27553 = ctx->ip_offset;
      D.27595 = monoeg_g_strdup_printf ("Type not compatible for mkrefany at 0x%04x", D.27553);
      vinfo->info.message = D.27595;
      vinfo->exception_type = 4;
      D.27555 = ctx->list;
      D.27596 = monoeg_g_slist_prepend (D.27555, vinfo);
      ctx->list = D.27596;
    }
    ctx->verifiable = 0;
    D.27551 = ctx->level;
    D.27557 = D.27551 & 16;
    if (D.27557 != 0) goto <D.27597>; else goto <D.27598>;
    <D.27597>:
    ctx->valid = 0;
    <D.27598>:
    <D.27593>:
    <D.27591>:
    <D.27588>:
  }
  <D.27571>:
  D.27599 = stack_push (ctx);
  D.27600 = mono_defaults.typed_reference_class;
  D.27601 = &D.27600->byval_arg;
  set_stack_value (ctx, D.27599, D.27601, 0);
}


do_load_token (struct VerifyContext * ctx, int token)
{
  int D.27603;
  struct MonoMethod * D.27606;
  unsigned char D.27607;
  unsigned char D.27608;
  unsigned int token.113;
  int D.27612;
  unsigned int D.27613;
  void * handle_class.114;
  struct MonoClass * D.27615;
  struct MonoClass * handle_class.115;
  unsigned int token.116;
  unsigned int D.27621;
  struct MonoImage * D.27622;
  int D.27623;
  int D.27626;
  unsigned int D.27627;
  gchar * D.27628;
  struct GSList * D.27629;
  struct GSList * D.27630;
  int D.27631;
  gchar * D.27632;
  struct GSList * D.27633;
  unsigned int token.117;
  struct MonoGenericContext * D.27635;
  gchar * D.27638;
  struct GSList * D.27639;
  struct MonoClass * D.27643;
  struct MonoClass * D.27647;
  struct MonoClass * D.27650;
  struct MonoType * D.27651;
  gchar * D.27653;
  struct GSList * D.27654;
  struct MonoType * D.27655;
  void * handle;
  struct MonoClass * handle_class;

  try
    {
      D.27603 = check_overflow (ctx);
      if (D.27603 == 0) goto <D.27604>; else goto <D.27605>;
      <D.27604>:
      return;
      <D.27605>:
      D.27606 = ctx->method;
      D.27607 = BIT_FIELD_REF <*D.27606, 8, 160>;
      D.27608 = D.27607 & 124;
      if (D.27608 != 0) goto <D.27609>; else goto <D.27610>;
      <D.27609>:
      D.27606 = ctx->method;
      token.113 = (unsigned int) token;
      handle = mono_method_get_wrapper_data (D.27606, token.113);
      D.27606 = ctx->method;
      D.27612 = token + 1;
      D.27613 = (unsigned int) D.27612;
      handle_class.114 = mono_method_get_wrapper_data (D.27606, D.27613);
      handle_class = handle_class.114;
      D.27615 = mono_defaults.typehandle_class;
      handle_class.115 = handle_class;
      if (D.27615 == handle_class.115) goto <D.27617>; else goto <D.27618>;
      <D.27617>:
      handle = &MEM[(struct MonoClass *)handle].byval_arg;
      <D.27618>:
      goto <D.27619>;
      <D.27610>:
      token.116 = (unsigned int) token;
      D.27621 = token.116 & 4278190080;
      switch (D.27621) <default: <D.21187>, case 16777216: <D.21179>, case 33554432: <D.21178>, case 67108864: <D.21181>, case 100663296: <D.21182>, case 167772160: <D.21184>, case 452984832: <D.21180>, case 721420288: <D.21183>>
      <D.21178>:
      <D.21179>:
      <D.21180>:
      <D.21181>:
      <D.21182>:
      <D.21183>:
      <D.21184>:
      D.27622 = ctx->image;
      token.113 = (unsigned int) token;
      D.27623 = token_bounds_check (D.27622, token.113);
      if (D.27623 == 0) goto <D.27624>; else goto <D.27625>;
      <D.27624>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27626 = token & 16777215;
        D.27627 = ctx->ip_offset;
        D.27628 = monoeg_g_strdup_printf ("Table index out of range 0x%x for token %x for ldtoken at 0x%04x", D.27626, token, D.27627);
        vinfo->info.message = D.27628;
        vinfo->exception_type = 3;
        D.27629 = ctx->list;
        D.27630 = monoeg_g_slist_prepend (D.27629, vinfo);
        ctx->list = D.27630;
      }
      ctx->valid = 0;
      return;
      <D.27625>:
      goto <D.21186>;
      <D.21187>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27631 = token >> 24;
        D.27627 = ctx->ip_offset;
        D.27632 = monoeg_g_strdup_printf ("Invalid table 0x%x for token 0x%x for ldtoken at 0x%04x", D.27631, token, D.27627);
        vinfo->info.message = D.27632;
        vinfo->exception_type = 3;
        D.27629 = ctx->list;
        D.27633 = monoeg_g_slist_prepend (D.27629, vinfo);
        ctx->list = D.27633;
      }
      ctx->valid = 0;
      return;
      <D.21186>:
      D.27622 = ctx->image;
      token.117 = (unsigned int) token;
      D.27635 = ctx->generic_context;
      handle = mono_ldtoken (D.27622, token.117, &handle_class, D.27635);
      <D.27619>:
      if (handle == 0B) goto <D.27636>; else goto <D.27637>;
      <D.27636>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27627 = ctx->ip_offset;
        D.27638 = monoeg_g_strdup_printf ("Invalid token 0x%x for ldtoken at 0x%04x", token, D.27627);
        vinfo->info.message = D.27638;
        vinfo->exception_type = 3;
        D.27629 = ctx->list;
        D.27639 = monoeg_g_slist_prepend (D.27629, vinfo);
        ctx->list = D.27639;
      }
      ctx->valid = 0;
      return;
      <D.27637>:
      D.27615 = mono_defaults.typehandle_class;
      handle_class.115 = handle_class;
      if (D.27615 == handle_class.115) goto <D.27640>; else goto <D.27641>;
      <D.27640>:
      mono_type_is_valid_in_context (ctx, handle);
      goto <D.27642>;
      <D.27641>:
      D.27643 = mono_defaults.methodhandle_class;
      handle_class.115 = handle_class;
      if (D.27643 == handle_class.115) goto <D.27644>; else goto <D.27645>;
      <D.27644>:
      mono_method_is_valid_in_context (ctx, handle);
      goto <D.27646>;
      <D.27645>:
      D.27647 = mono_defaults.fieldhandle_class;
      handle_class.115 = handle_class;
      if (D.27647 == handle_class.115) goto <D.27648>; else goto <D.27649>;
      <D.27648>:
      D.27650 = MEM[(struct MonoClassField *)handle].parent;
      D.27651 = &D.27650->byval_arg;
      mono_type_is_valid_in_context (ctx, D.27651);
      goto <D.27652>;
      <D.27649>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27627 = ctx->ip_offset;
        D.27653 = monoeg_g_strdup_printf ("Invalid ldtoken type %x at 0x%04x", token, D.27627);
        vinfo->info.message = D.27653;
        vinfo->exception_type = 12;
        D.27629 = ctx->list;
        D.27654 = monoeg_g_slist_prepend (D.27629, vinfo);
        ctx->list = D.27654;
      }
      ctx->valid = 0;
      <D.27652>:
      <D.27646>:
      <D.27642>:
      handle_class.115 = handle_class;
      D.27655 = mono_class_get_type (handle_class.115);
      stack_push_val (ctx, 6, D.27655);
    }
  finally
    {
      handle_class = {CLOBBER};
    }
}


is_correct_endfinally (struct MonoMethodHeader * header, guint offset)
{
  struct MonoExceptionClause * D.27659;
  unsigned int i.118;
  unsigned int D.27661;
  unsigned int D.27662;
  unsigned int D.27665;
  unsigned int D.27666;
  unsigned int D.27669;
  _Bool D.27670;
  _Bool D.27671;
  _Bool D.27672;
  int D.27675;
  <unnamed-unsigned:15> D.27676;
  int D.27677;
  int i;
  struct MonoExceptionClause * clause;

  i = 0;
  goto <D.20431>;
  <D.20430>:
  D.27659 = header->clauses;
  i.118 = (unsigned int) i;
  D.27661 = i.118 * 24;
  clause = D.27659 + D.27661;
  D.27662 = clause->handler_offset;
  if (D.27662 <= offset) goto <D.27663>; else goto <D.27664>;
  <D.27663>:
  D.27662 = clause->handler_offset;
  D.27665 = clause->handler_len;
  D.27666 = D.27662 + D.27665;
  if (D.27666 > offset) goto <D.27667>; else goto <D.27668>;
  <D.27667>:
  D.27669 = clause->flags;
  D.27670 = D.27669 == 4;
  D.27671 = D.27669 == 2;
  D.27672 = D.27670 | D.27671;
  if (D.27672 != 0) goto <D.27673>; else goto <D.27674>;
  <D.27673>:
  D.27675 = 1;
  return D.27675;
  <D.27674>:
  <D.27668>:
  <D.27664>:
  i = i + 1;
  <D.20431>:
  D.27676 = header->num_clauses;
  D.27677 = (int) D.27676;
  if (D.27677 > i) goto <D.20430>; else goto <D.20432>;
  <D.20432>:
  D.27675 = 0;
  return D.27675;
}


do_leave (struct VerifyContext * ctx, int delta)
{
  unsigned int D.27679;
  int D.27680;
  int D.27683;
  gchar * D.27685;
  struct GSList * D.27686;
  struct GSList * D.27687;
  struct MonoMethodHeader * D.27688;
  unsigned int target.119;
  int D.27690;
  int D.27695;
  int D.27697;
  int D.27698;
  gchar * D.27699;
  struct GSList * D.27700;
  int D.27701;
  int target;

  D.27679 = ctx->ip_offset;
  D.27680 = (int) D.27679;
  target = D.27680 + delta;
  D.27683 = ctx->code_size;
  if (D.27683 <= target) goto <D.27681>; else goto <D.27684>;
  <D.27684>:
  if (target < 0) goto <D.27681>; else goto <D.27682>;
  <D.27681>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.27679 = ctx->ip_offset;
    D.27685 = monoeg_g_strdup_printf ("Branch target out of code at 0x%04x", D.27679);
    vinfo->info.message = D.27685;
    vinfo->exception_type = 3;
    D.27686 = ctx->list;
    D.27687 = monoeg_g_slist_prepend (D.27686, vinfo);
    ctx->list = D.27687;
  }
  ctx->valid = 0;
  <D.27682>:
  D.27688 = ctx->header;
  D.27679 = ctx->ip_offset;
  target.119 = (unsigned int) target;
  D.27690 = is_correct_leave (D.27688, D.27679, target.119);
  if (D.27690 == 0) goto <D.27691>; else goto <D.27692>;
  <D.27691>:
  D.27695 = ctx->verifiable;
  if (D.27695 != 0) goto <D.27693>; else goto <D.27696>;
  <D.27696>:
  D.27697 = ctx->level;
  D.27698 = D.27697 & 128;
  if (D.27698 != 0) goto <D.27693>; else goto <D.27694>;
  <D.27693>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27679 = ctx->ip_offset;
    D.27699 = monoeg_g_strdup_printf ("Leave not allowed in finally block at 0x%04x", D.27679);
    vinfo->info.message = D.27699;
    vinfo->exception_type = 4;
    D.27686 = ctx->list;
    D.27700 = monoeg_g_slist_prepend (D.27686, vinfo);
    ctx->list = D.27700;
  }
  ctx->verifiable = 0;
  D.27697 = ctx->level;
  D.27701 = D.27697 & 16;
  if (D.27701 != 0) goto <D.27702>; else goto <D.27703>;
  <D.27702>:
  ctx->valid = 0;
  <D.27703>:
  <D.27694>:
  <D.27692>:
  ctx->eval.size = 0;
  ctx->target = target;
}


is_correct_leave (struct MonoMethodHeader * header, guint offset, guint target)
{
  struct MonoExceptionClause * D.27704;
  unsigned int i.120;
  unsigned int D.27706;
  unsigned int D.27709;
  unsigned int D.27712;
  unsigned int D.27715;
  unsigned int D.27716;
  int D.27720;
  unsigned int D.27723;
  <unnamed-unsigned:15> D.27728;
  int D.27729;
  int i;
  struct MonoExceptionClause * clause;

  i = 0;
  goto <D.20413>;
  <D.20412>:
  D.27704 = header->clauses;
  i.120 = (unsigned int) i;
  D.27706 = i.120 * 24;
  clause = D.27704 + D.27706;
  D.27709 = clause->flags;
  if (D.27709 == 2) goto <D.27710>; else goto <D.27711>;
  <D.27710>:
  D.27712 = clause->handler_offset;
  if (D.27712 <= offset) goto <D.27713>; else goto <D.27714>;
  <D.27713>:
  D.27712 = clause->handler_offset;
  D.27715 = clause->handler_len;
  D.27716 = D.27712 + D.27715;
  if (D.27716 > offset) goto <D.27717>; else goto <D.27718>;
  <D.27717>:
  D.27712 = clause->handler_offset;
  if (D.27712 > target) goto <D.27707>; else goto <D.27719>;
  <D.27719>:
  D.27712 = clause->handler_offset;
  D.27715 = clause->handler_len;
  D.27716 = D.27712 + D.27715;
  if (D.27716 <= target) goto <D.27707>; else goto <D.27708>;
  <D.27707>:
  D.27720 = 0;
  return D.27720;
  <D.27708>:
  <D.27718>:
  <D.27714>:
  <D.27711>:
  D.27709 = clause->flags;
  if (D.27709 == 1) goto <D.27721>; else goto <D.27722>;
  <D.27721>:
  D.27723 = clause->data.filter_offset;
  if (D.27723 <= offset) goto <D.27724>; else goto <D.27725>;
  <D.27724>:
  D.27712 = clause->handler_offset;
  if (D.27712 > offset) goto <D.27726>; else goto <D.27727>;
  <D.27726>:
  D.27720 = 0;
  return D.27720;
  <D.27727>:
  <D.27725>:
  <D.27722>:
  i = i + 1;
  <D.20413>:
  D.27728 = header->num_clauses;
  D.27729 = (int) D.27728;
  if (D.27729 > i) goto <D.20412>; else goto <D.20414>;
  <D.20414>:
  D.27720 = 1;
  return D.27720;
}


store_local (struct VerifyContext * ctx, guint32 arg)
{
  int D.27731;
  unsigned int D.27732;
  unsigned int D.27735;
  unsigned int D.27736;
  gchar * D.27737;
  struct GSList * D.27738;
  struct GSList * D.27739;
  int D.27740;
  struct MonoType * * D.27743;
  unsigned int D.27744;
  struct MonoType * * D.27745;
  struct MonoType * D.27746;
  unsigned char D.27747;
  unsigned char D.27748;
  int D.27751;
  int D.27756;
  int D.27758;
  int D.27759;
  gchar * D.27760;
  struct GSList * D.27761;
  int D.27762;
  int D.27765;
  gchar * D.27771;
  struct GSList * D.27772;
  struct ILStackDesc * value;

  D.27731 = ctx->num_locals;
  D.27732 = (unsigned int) D.27731;
  if (D.27732 <= arg) goto <D.27733>; else goto <D.27734>;
  <D.27733>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.27735 = arg + 1;
    D.27736 = ctx->ip_offset;
    D.27737 = monoeg_g_strdup_printf ("Method doesn\'t have local var %d at 0x%04x", D.27735, D.27736);
    vinfo->info.message = D.27737;
    vinfo->exception_type = 3;
    D.27738 = ctx->list;
    D.27739 = monoeg_g_slist_prepend (D.27738, vinfo);
    ctx->list = D.27739;
  }
  ctx->valid = 0;
  return;
  <D.27734>:
  D.27740 = check_underflow (ctx, 1);
  if (D.27740 == 0) goto <D.27741>; else goto <D.27742>;
  <D.27741>:
  return;
  <D.27742>:
  value = stack_pop (ctx);
  D.27743 = ctx->locals;
  D.27744 = arg * 4;
  D.27745 = D.27743 + D.27744;
  D.27746 = *D.27745;
  D.27747 = BIT_FIELD_REF <*D.27746, 8, 56>;
  D.27748 = D.27747 & 64;
  if (D.27748 != 0) goto <D.27749>; else goto <D.27750>;
  <D.27749>:
  D.27751 = stack_slot_is_managed_mutability_pointer (value);
  if (D.27751 != 0) goto <D.27752>; else goto <D.27753>;
  <D.27752>:
  D.27756 = ctx->verifiable;
  if (D.27756 != 0) goto <D.27754>; else goto <D.27757>;
  <D.27757>:
  D.27758 = ctx->level;
  D.27759 = D.27758 & 128;
  if (D.27759 != 0) goto <D.27754>; else goto <D.27755>;
  <D.27754>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27736 = ctx->ip_offset;
    D.27760 = monoeg_g_strdup_printf ("Cannot use a readonly managed reference when storing on a local variable at 0x%04x", D.27736);
    vinfo->info.message = D.27760;
    vinfo->exception_type = 4;
    D.27738 = ctx->list;
    D.27761 = monoeg_g_slist_prepend (D.27738, vinfo);
    ctx->list = D.27761;
  }
  ctx->verifiable = 0;
  D.27758 = ctx->level;
  D.27762 = D.27758 & 16;
  if (D.27762 != 0) goto <D.27763>; else goto <D.27764>;
  <D.27763>:
  ctx->valid = 0;
  <D.27764>:
  <D.27755>:
  <D.27753>:
  <D.27750>:
  D.27743 = ctx->locals;
  D.27744 = arg * 4;
  D.27745 = D.27743 + D.27744;
  D.27746 = *D.27745;
  D.27765 = verify_stack_type_compatibility (ctx, D.27746, value);
  if (D.27765 == 0) goto <D.27766>; else goto <D.27767>;
  <D.27766>:
  {
    char * expected;
    char * found;

    D.27743 = ctx->locals;
    D.27744 = arg * 4;
    D.27745 = D.27743 + D.27744;
    D.27746 = *D.27745;
    expected = mono_type_full_name (D.27746);
    found = stack_slot_full_name (value);
    D.27756 = ctx->verifiable;
    if (D.27756 != 0) goto <D.27768>; else goto <D.27770>;
    <D.27770>:
    D.27758 = ctx->level;
    D.27759 = D.27758 & 128;
    if (D.27759 != 0) goto <D.27768>; else goto <D.27769>;
    <D.27768>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 8;
      D.27736 = ctx->ip_offset;
      D.27771 = monoeg_g_strdup_printf ("Incompatible type \'%s\' on stack cannot be stored to local %d with type \'%s\' at 0x%04x", found, arg, expected, D.27736);
      vinfo->info.message = D.27771;
      vinfo->exception_type = 4;
      D.27738 = ctx->list;
      D.27772 = monoeg_g_slist_prepend (D.27738, vinfo);
      ctx->list = D.27772;
    }
    ctx->verifiable = 0;
    D.27758 = ctx->level;
    D.27762 = D.27758 & 16;
    if (D.27762 != 0) goto <D.27773>; else goto <D.27774>;
    <D.27773>:
    ctx->valid = 0;
    <D.27774>:
    <D.27769>:
    monoeg_g_free (expected);
    monoeg_g_free (found);
  }
  <D.27767>:
}


do_cmp_op (struct VerifyContext * ctx, const unsigned char[6] * table, guint32 opcode)
{
  int D.27776;
  int D.27781;
  int D.27784;
  struct MonoClass * D.27787;
  struct MonoType * D.27788;
  int D.27789;
  int D.27792;
  int D.27798;
  int D.27800;
  unsigned int idxa.121;
  unsigned int D.27802;
  const unsigned char[6] * D.27803;
  int D.27808;
  int D.27810;
  int D.27811;
  const char * D.27812;
  const char * D.27813;
  unsigned int D.27814;
  gchar * D.27815;
  struct GSList * D.27816;
  struct GSList * D.27817;
  int D.27818;
  signed char res.122;
  const char * D.27828;
  const char * D.27829;
  gchar * D.27830;
  struct GSList * D.27831;
  struct ILStackDesc * a;
  struct ILStackDesc * b;
  int idxa;
  int idxb;
  unsigned char res;

  D.27776 = check_underflow (ctx, 2);
  if (D.27776 == 0) goto <D.27777>; else goto <D.27778>;
  <D.27777>:
  return;
  <D.27778>:
  b = stack_pop (ctx);
  a = stack_pop (ctx);
  if (opcode == 3) goto <D.27779>; else goto <D.27780>;
  <D.27779>:
  D.27781 = stack_slot_get_type (a);
  if (D.27781 == 6) goto <D.27782>; else goto <D.27783>;
  <D.27782>:
  D.27784 = stack_slot_get_type (b);
  if (D.27784 == 6) goto <D.27785>; else goto <D.27786>;
  <D.27785>:
  D.27787 = mono_defaults.int32_class;
  D.27788 = &D.27787->byval_arg;
  stack_push_val (ctx, 1, D.27788);
  return;
  <D.27786>:
  <D.27783>:
  <D.27780>:
  idxa = stack_slot_get_underlying_type (a);
  D.27789 = stack_slot_is_managed_pointer (a);
  if (D.27789 != 0) goto <D.27790>; else goto <D.27791>;
  <D.27790>:
  idxa = 5;
  <D.27791>:
  idxb = stack_slot_get_underlying_type (b);
  D.27792 = stack_slot_is_managed_pointer (b);
  if (D.27792 != 0) goto <D.27793>; else goto <D.27794>;
  <D.27793>:
  idxb = 5;
  <D.27794>:
  D.27798 = stack_slot_is_complex_type_not_reference_type (a);
  if (D.27798 != 0) goto <D.27795>; else goto <D.27799>;
  <D.27799>:
  D.27800 = stack_slot_is_complex_type_not_reference_type (b);
  if (D.27800 != 0) goto <D.27795>; else goto <D.27796>;
  <D.27795>:
  res = 0;
  goto <D.27797>;
  <D.27796>:
  idxa = idxa + -1;
  idxb = idxb + -1;
  idxa.121 = (unsigned int) idxa;
  D.27802 = idxa.121 * 6;
  D.27803 = table + D.27802;
  res = *D.27803[idxb];
  <D.27797>:
  if (res == 0) goto <D.27804>; else goto <D.27805>;
  <D.27804>:
  D.27808 = ctx->verifiable;
  if (D.27808 != 0) goto <D.27806>; else goto <D.27809>;
  <D.27809>:
  D.27810 = ctx->level;
  D.27811 = D.27810 & 128;
  if (D.27811 != 0) goto <D.27806>; else goto <D.27807>;
  <D.27806>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27812 = stack_slot_get_name (a);
    D.27813 = stack_slot_get_name (b);
    D.27814 = ctx->ip_offset;
    D.27815 = monoeg_g_strdup_printf ("Compare instruction applyed to ill formed stack (%s x %s) at 0x%04x", D.27812, D.27813, D.27814);
    vinfo->info.message = D.27815;
    vinfo->exception_type = 4;
    D.27816 = ctx->list;
    D.27817 = monoeg_g_slist_prepend (D.27816, vinfo);
    ctx->list = D.27817;
  }
  ctx->verifiable = 0;
  D.27810 = ctx->level;
  D.27818 = D.27810 & 16;
  if (D.27818 != 0) goto <D.27819>; else goto <D.27820>;
  <D.27819>:
  ctx->valid = 0;
  <D.27820>:
  <D.27807>:
  goto <D.27821>;
  <D.27805>:
  res.122 = (signed char) res;
  if (res.122 < 0) goto <D.27823>; else goto <D.27824>;
  <D.27823>:
  D.27808 = ctx->verifiable;
  if (D.27808 != 0) goto <D.27825>; else goto <D.27827>;
  <D.27827>:
  D.27810 = ctx->level;
  D.27811 = D.27810 & 128;
  if (D.27811 != 0) goto <D.27825>; else goto <D.27826>;
  <D.27825>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27828 = stack_slot_get_name (a);
    D.27829 = stack_slot_get_name (b);
    D.27814 = ctx->ip_offset;
    D.27830 = monoeg_g_strdup_printf ("Compare instruction is not verifiable (%s x %s) at 0x%04x", D.27828, D.27829, D.27814);
    vinfo->info.message = D.27830;
    vinfo->exception_type = 4;
    D.27816 = ctx->list;
    D.27831 = monoeg_g_slist_prepend (D.27816, vinfo);
    ctx->list = D.27831;
  }
  ctx->verifiable = 0;
  D.27810 = ctx->level;
  D.27818 = D.27810 & 16;
  if (D.27818 != 0) goto <D.27832>; else goto <D.27833>;
  <D.27832>:
  ctx->valid = 0;
  <D.27833>:
  <D.27826>:
  res = res & 127;
  <D.27824>:
  <D.27821>:
  D.27787 = mono_defaults.int32_class;
  D.27788 = &D.27787->byval_arg;
  stack_push_val (ctx, 1, D.27788);
}


store_arg (struct VerifyContext * ctx, guint32 arg)
{
  int D.27835;
  unsigned int D.27836;
  int D.27841;
  int D.27843;
  int D.27844;
  unsigned int D.27845;
  unsigned int D.27846;
  gchar * D.27847;
  struct GSList * D.27848;
  struct GSList * D.27849;
  int D.27850;
  int D.27853;
  int D.27856;
  struct MonoType * * D.27859;
  unsigned int D.27860;
  struct MonoType * * D.27861;
  struct MonoType * D.27862;
  int D.27863;
  const char * D.27869;
  gchar * D.27870;
  struct GSList * D.27871;
  struct MonoMethod * D.27876;
  short unsigned int D.27877;
  int D.27878;
  int D.27879;
  struct ILStackDesc * value;

  D.27835 = ctx->max_args;
  D.27836 = (unsigned int) D.27835;
  if (D.27836 <= arg) goto <D.27837>; else goto <D.27838>;
  <D.27837>:
  D.27841 = ctx->verifiable;
  if (D.27841 != 0) goto <D.27839>; else goto <D.27842>;
  <D.27842>:
  D.27843 = ctx->level;
  D.27844 = D.27843 & 128;
  if (D.27844 != 0) goto <D.27839>; else goto <D.27840>;
  <D.27839>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27845 = arg + 1;
    D.27846 = ctx->ip_offset;
    D.27847 = monoeg_g_strdup_printf ("Method doesn\'t have argument %d at 0x%04x", D.27845, D.27846);
    vinfo->info.message = D.27847;
    vinfo->exception_type = 4;
    D.27848 = ctx->list;
    D.27849 = monoeg_g_slist_prepend (D.27848, vinfo);
    ctx->list = D.27849;
  }
  ctx->verifiable = 0;
  D.27843 = ctx->level;
  D.27850 = D.27843 & 16;
  if (D.27850 != 0) goto <D.27851>; else goto <D.27852>;
  <D.27851>:
  ctx->valid = 0;
  <D.27852>:
  <D.27840>:
  D.27853 = check_underflow (ctx, 1);
  if (D.27853 != 0) goto <D.27854>; else goto <D.27855>;
  <D.27854>:
  stack_pop (ctx);
  <D.27855>:
  return;
  <D.27838>:
  D.27856 = check_underflow (ctx, 1);
  if (D.27856 != 0) goto <D.27857>; else goto <D.27858>;
  <D.27857>:
  value = stack_pop (ctx);
  D.27859 = ctx->params;
  D.27860 = arg * 4;
  D.27861 = D.27859 + D.27860;
  D.27862 = *D.27861;
  D.27863 = verify_stack_type_compatibility (ctx, D.27862, value);
  if (D.27863 == 0) goto <D.27864>; else goto <D.27865>;
  <D.27864>:
  D.27841 = ctx->verifiable;
  if (D.27841 != 0) goto <D.27866>; else goto <D.27868>;
  <D.27868>:
  D.27843 = ctx->level;
  D.27844 = D.27843 & 128;
  if (D.27844 != 0) goto <D.27866>; else goto <D.27867>;
  <D.27866>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27869 = stack_slot_get_name (value);
    D.27846 = ctx->ip_offset;
    D.27870 = monoeg_g_strdup_printf ("Incompatible type %s in argument store at 0x%04x", D.27869, D.27846);
    vinfo->info.message = D.27870;
    vinfo->exception_type = 4;
    D.27848 = ctx->list;
    D.27871 = monoeg_g_slist_prepend (D.27848, vinfo);
    ctx->list = D.27871;
  }
  ctx->verifiable = 0;
  D.27843 = ctx->level;
  D.27850 = D.27843 & 16;
  if (D.27850 != 0) goto <D.27872>; else goto <D.27873>;
  <D.27872>:
  ctx->valid = 0;
  <D.27873>:
  <D.27867>:
  <D.27865>:
  <D.27858>:
  if (arg == 0) goto <D.27874>; else goto <D.27875>;
  <D.27874>:
  D.27876 = ctx->method;
  D.27877 = D.27876->flags;
  D.27878 = (int) D.27877;
  D.27879 = D.27878 & 16;
  if (D.27879 == 0) goto <D.27880>; else goto <D.27881>;
  <D.27880>:
  ctx->has_this_store = 1;
  <D.27881>:
  <D.27875>:
}


check_overflow (struct VerifyContext * ctx)
{
  short unsigned int D.27883;
  int D.27884;
  int D.27885;
  int D.27888;
  unsigned int D.27889;
  gchar * D.27890;
  struct GSList * D.27891;
  struct GSList * D.27892;
  int D.27893;

  D.27883 = ctx->eval.size;
  D.27884 = (int) D.27883;
  D.27885 = ctx->max_stack;
  if (D.27884 >= D.27885) goto <D.27886>; else goto <D.27887>;
  <D.27886>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.27883 = ctx->eval.size;
    D.27884 = (int) D.27883;
    D.27888 = D.27884 + 1;
    D.27889 = ctx->ip_offset;
    D.27890 = monoeg_g_strdup_printf ("Method doesn\'t have stack-depth %d at 0x%04x", D.27888, D.27889);
    vinfo->info.message = D.27890;
    vinfo->exception_type = 3;
    D.27891 = ctx->list;
    D.27892 = monoeg_g_slist_prepend (D.27891, vinfo);
    ctx->list = D.27892;
  }
  ctx->valid = 0;
  D.27893 = 0;
  return D.27893;
  <D.27887>:
  D.27893 = 1;
  return D.27893;
}


stack_push (struct VerifyContext * ctx)
{
  short unsigned int D.27895;
  int D.27896;
  int D.27897;
  _Bool D.27898;
  long int D.27899;
  long int D.27900;
  short unsigned int D.27903;
  _Bool D.27904;
  long int D.27905;
  long int D.27906;
  struct ILCodeDesc * D.27909;
  int D.27910;
  struct ILStackDesc * D.27911;
  struct ILStackDesc * D.27912;
  short unsigned int D.27913;
  short unsigned int D.27914;
  unsigned int D.27915;
  unsigned int D.27916;

  D.27895 = ctx->eval.size;
  D.27896 = (int) D.27895;
  D.27897 = ctx->max_stack;
  D.27898 = D.27896 >= D.27897;
  D.27899 = (long int) D.27898;
  D.27900 = __builtin_expect (D.27899, 0);
  if (D.27900 != 0) goto <D.27901>; else goto <D.27902>;
  <D.27901>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "verify.c", 1589, "ctx->eval.size < ctx->max_stack");
  <D.27902>:
  D.27895 = ctx->eval.size;
  D.27903 = ctx->eval.max_size;
  D.27904 = D.27895 > D.27903;
  D.27905 = (long int) D.27904;
  D.27906 = __builtin_expect (D.27905, 0);
  if (D.27906 != 0) goto <D.27907>; else goto <D.27908>;
  <D.27907>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "verify.c", 1590, "ctx->eval.size <= ctx->eval.max_size");
  <D.27908>:
  D.27909 = &ctx->eval;
  D.27895 = ctx->eval.size;
  D.27896 = (int) D.27895;
  D.27910 = D.27896 + 1;
  ensure_stack_size (D.27909, D.27910);
  D.27912 = ctx->eval.stack;
  D.27895 = ctx->eval.size;
  D.27913 = D.27895;
  D.27914 = D.27913 + 1;
  ctx->eval.size = D.27914;
  D.27915 = (unsigned int) D.27913;
  D.27916 = D.27915 * 12;
  D.27911 = D.27912 + D.27916;
  return D.27911;
}


set_stack_value (struct VerifyContext * ctx, struct ILStackDesc * stack, struct MonoType * type, int take_addr)
{
  unsigned char D.27918;
  unsigned char D.27921;
  unsigned char D.27922;
  int D.27924;
  int D.27925;
  int D.27926;
  int D.27927;
  int D.27928;
  int D.27929;
  int D.27930;
  int D.27935;
  unsigned int D.27936;
  gchar * D.27937;
  struct GSList * D.27938;
  struct GSList * D.27939;
  gboolean D.27940;
  gchar * D.27941;
  struct GSList * D.27942;
  int mask;
  int type_kind;
  void handle_enum = <<< error >>>;

  mask = 0;
  D.27918 = type->type;
  type_kind = (int) D.27918;
  D.27921 = BIT_FIELD_REF <*type, 8, 56>;
  D.27922 = D.27921 & 64;
  if (D.27922 != 0) goto <D.27919>; else goto <D.27923>;
  <D.27923>:
  if (take_addr != 0) goto <D.27919>; else goto <D.27920>;
  <D.27919>:
  mask = 256;
  <D.27920>:
  handle_enum:
  stack->type = type;
  switch (type_kind) <default: <D.20640>, case 2: <D.20613>, case 3: <D.20616>, case 4: <D.20611>, case 5: <D.20612>, case 6: <D.20614>, case 7: <D.20615>, case 8: <D.20617>, case 9: <D.20618>, case 10: <D.20632>, case 11: <D.20633>, case 12: <D.20634>, case 13: <D.20635>, case 14: <D.20626>, case 15: <D.20623>, case 17: <D.20637>, case 18: <D.20625>, case 19: <D.20630>, case 20: <D.20629>, case 21: <D.20636>, case 22: <D.20624>, case 24: <D.20620>, case 25: <D.20621>, case 27: <D.20622>, case 28: <D.20627>, case 29: <D.20628>, case 30: <D.20631>>
  <D.20611>:
  <D.20612>:
  <D.20613>:
  <D.20614>:
  <D.20615>:
  <D.20616>:
  <D.20617>:
  <D.20618>:
  D.27924 = mask | 1;
  stack->stype = D.27924;
  goto <D.20619>;
  <D.20620>:
  <D.20621>:
  D.27925 = mask | 3;
  stack->stype = D.27925;
  goto <D.20619>;
  <D.20622>:
  <D.20623>:
  <D.20624>:
  D.27926 = mask | 5;
  stack->stype = D.27926;
  goto <D.20619>;
  <D.20625>:
  <D.20626>:
  <D.20627>:
  <D.20628>:
  <D.20629>:
  <D.20630>:
  <D.20631>:
  D.27927 = mask | 6;
  stack->stype = D.27927;
  goto <D.20619>;
  <D.20632>:
  <D.20633>:
  D.27928 = mask | 2;
  stack->stype = D.27928;
  goto <D.20619>;
  <D.20634>:
  <D.20635>:
  D.27929 = mask | 4;
  stack->stype = D.27929;
  goto <D.20619>;
  <D.20636>:
  <D.20637>:
  D.27930 = mono_type_is_enum_type (type);
  if (D.27930 != 0) goto <D.27931>; else goto <D.27932>;
  <D.27931>:
  {
    struct MonoType * utype;

    utype = mono_type_get_underlying_type_any (type);
    if (utype == 0B) goto <D.27933>; else goto <D.27934>;
    <D.27933>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.27918 = type->type;
      D.27935 = (int) D.27918;
      D.27936 = ctx->ip_offset;
      D.27937 = monoeg_g_strdup_printf ("Could not resolve underlying type of %x at %d", D.27935, D.27936);
      vinfo->info.message = D.27937;
      vinfo->exception_type = 3;
      D.27938 = ctx->list;
      D.27939 = monoeg_g_slist_prepend (D.27938, vinfo);
      ctx->list = D.27939;
    }
    ctx->valid = 0;
    D.27940 = 0;
    return D.27940;
    <D.27934>:
    type = utype;
    D.27918 = type->type;
    type_kind = (int) D.27918;
    goto handle_enum;
  }
  <D.27932>:
  D.27927 = mask | 6;
  stack->stype = D.27927;
  goto <D.20619>;
  <D.20640>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.27918 = type->type;
    D.27935 = (int) D.27918;
    D.27936 = ctx->ip_offset;
    D.27941 = monoeg_g_strdup_printf ("Illegal value set on stack 0x%02x at %d", D.27935, D.27936);
    vinfo->info.message = D.27941;
    vinfo->exception_type = 3;
    D.27938 = ctx->list;
    D.27942 = monoeg_g_slist_prepend (D.27938, vinfo);
    ctx->list = D.27942;
  }
  ctx->valid = 0;
  D.27940 = 0;
  return D.27940;
  <D.20619>:
  D.27940 = 1;
  return D.27940;
}


do_load_function_ptr (struct VerifyContext * ctx, guint32 token, gboolean virtual)
{
  int D.27946;
  int D.27951;
  struct MonoMethod * D.27954;
  unsigned char D.27955;
  unsigned char D.27956;
  unsigned int D.27961;
  gchar * D.27962;
  struct GSList * D.27963;
  struct GSList * D.27964;
  unsigned int D.27969;
  _Bool D.27970;
  _Bool D.27971;
  _Bool D.27972;
  unsigned int D.27974;
  struct MonoImage * D.27975;
  int D.27976;
  gchar * D.27977;
  struct GSList * D.27978;
  int token.123;
  const char * iftmp.124;
  int D.27986;
  int D.27991;
  int D.27993;
  int D.27994;
  gchar * D.27995;
  struct GSList * D.27996;
  int D.27997;
  int D.28004;
  struct MonoType * D.28006;
  unsigned char D.28007;
  gchar * D.28011;
  struct GSList * D.28012;
  short unsigned int D.28015;
  int D.28016;
  int D.28017;
  gchar * D.28023;
  struct GSList * D.28024;
  struct MonoClass * D.28027;
  struct MonoType * D.28028;
  int D.28029;
  gchar * D.28035;
  struct GSList * D.28036;
  int D.28039;
  int D.28042;
  gchar * D.28048;
  struct GSList * D.28049;
  struct MonoType * D.28052;
  struct ILStackDesc * top;
  struct MonoMethod * method;

  if (virtual != 0) goto <D.27944>; else goto <D.27945>;
  <D.27944>:
  D.27946 = check_underflow (ctx, 1);
  if (D.27946 == 0) goto <D.27947>; else goto <D.27948>;
  <D.27947>:
  return;
  <D.27948>:
  <D.27945>:
  if (virtual == 0) goto <D.27949>; else goto <D.27950>;
  <D.27949>:
  D.27951 = check_overflow (ctx);
  if (D.27951 == 0) goto <D.27952>; else goto <D.27953>;
  <D.27952>:
  return;
  <D.27953>:
  <D.27950>:
  D.27954 = ctx->method;
  D.27955 = BIT_FIELD_REF <*D.27954, 8, 160>;
  D.27956 = D.27955 & 124;
  if (D.27956 != 0) goto <D.27957>; else goto <D.27958>;
  <D.27957>:
  D.27954 = ctx->method;
  method = mono_method_get_wrapper_data (D.27954, token);
  if (method == 0B) goto <D.27959>; else goto <D.27960>;
  <D.27959>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.27961 = ctx->ip_offset;
    D.27962 = monoeg_g_strdup_printf ("Invalid token %x for ldftn  at 0x%04x", token, D.27961);
    vinfo->info.message = D.27962;
    vinfo->exception_type = 12;
    D.27963 = ctx->list;
    D.27964 = monoeg_g_slist_prepend (D.27963, vinfo);
    ctx->list = D.27964;
  }
  ctx->valid = 0;
  return;
  <D.27960>:
  goto <D.27965>;
  <D.27958>:
  D.27969 = token >> 24;
  D.27970 = D.27969 != 6;
  D.27971 = D.27969 != 10;
  D.27972 = D.27970 & D.27971;
  if (D.27972 != 0) goto <D.27973>; else goto <D.27966>;
  <D.27973>:
  D.27974 = token >> 24;
  if (D.27974 != 43) goto <D.27967>; else goto <D.27966>;
  <D.27966>:
  D.27975 = ctx->image;
  D.27976 = token_bounds_check (D.27975, token);
  if (D.27976 == 0) goto <D.27967>; else goto <D.27968>;
  <D.27967>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.27961 = ctx->ip_offset;
    D.27977 = monoeg_g_strdup_printf ("Invalid token %x for ldftn  at 0x%04x", token, D.27961);
    vinfo->info.message = D.27977;
    vinfo->exception_type = 12;
    D.27963 = ctx->list;
    D.27978 = monoeg_g_slist_prepend (D.27963, vinfo);
    ctx->list = D.27978;
  }
  ctx->valid = 0;
  return;
  <D.27968>:
  token.123 = (int) token;
  if (virtual != 0) goto <D.27981>; else goto <D.27982>;
  <D.27981>:
  iftmp.124 = "ldvirtfrn";
  goto <D.27983>;
  <D.27982>:
  iftmp.124 = "ldftn";
  <D.27983>:
  method = verifier_load_method (ctx, token.123, iftmp.124);
  if (method == 0B) goto <D.27984>; else goto <D.27985>;
  <D.27984>:
  return;
  <D.27985>:
  <D.27965>:
  D.27986 = mono_method_is_constructor (method);
  if (D.27986 != 0) goto <D.27987>; else goto <D.27988>;
  <D.27987>:
  D.27991 = ctx->verifiable;
  if (D.27991 != 0) goto <D.27989>; else goto <D.27992>;
  <D.27992>:
  D.27993 = ctx->level;
  D.27994 = D.27993 & 128;
  if (D.27994 != 0) goto <D.27989>; else goto <D.27990>;
  <D.27989>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27961 = ctx->ip_offset;
    D.27995 = monoeg_g_strdup_printf ("Cannot use ldftn with a constructor at 0x%04x", D.27961);
    vinfo->info.message = D.27995;
    vinfo->exception_type = 4;
    D.27963 = ctx->list;
    D.27996 = monoeg_g_slist_prepend (D.27963, vinfo);
    ctx->list = D.27996;
  }
  ctx->verifiable = 0;
  D.27993 = ctx->level;
  D.27997 = D.27993 & 16;
  if (D.27997 != 0) goto <D.27998>; else goto <D.27999>;
  <D.27998>:
  ctx->valid = 0;
  <D.27999>:
  <D.27990>:
  <D.27988>:
  if (virtual != 0) goto <D.28000>; else goto <D.28001>;
  <D.28000>:
  {
    struct ILStackDesc * top;

    top = stack_pop (ctx);
    D.28004 = stack_slot_get_type (top);
    if (D.28004 != 6) goto <D.28002>; else goto <D.28005>;
    <D.28005>:
    D.28006 = top->type;
    D.28007 = D.28006->type;
    if (D.28007 == 17) goto <D.28002>; else goto <D.28003>;
    <D.28002>:
    D.27991 = ctx->verifiable;
    if (D.27991 != 0) goto <D.28008>; else goto <D.28010>;
    <D.28010>:
    D.27993 = ctx->level;
    D.27994 = D.27993 & 128;
    if (D.27994 != 0) goto <D.28008>; else goto <D.28009>;
    <D.28008>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 8;
      D.27961 = ctx->ip_offset;
      D.28011 = monoeg_g_strdup_printf ("Invalid argument to ldvirtftn at 0x%04x", D.27961);
      vinfo->info.message = D.28011;
      vinfo->exception_type = 4;
      D.27963 = ctx->list;
      D.28012 = monoeg_g_slist_prepend (D.27963, vinfo);
      ctx->list = D.28012;
    }
    ctx->verifiable = 0;
    D.27993 = ctx->level;
    D.27997 = D.27993 & 16;
    if (D.27997 != 0) goto <D.28013>; else goto <D.28014>;
    <D.28013>:
    ctx->valid = 0;
    <D.28014>:
    <D.28009>:
    <D.28003>:
    D.28015 = method->flags;
    D.28016 = (int) D.28015;
    D.28017 = D.28016 & 16;
    if (D.28017 != 0) goto <D.28018>; else goto <D.28019>;
    <D.28018>:
    D.27991 = ctx->verifiable;
    if (D.27991 != 0) goto <D.28020>; else goto <D.28022>;
    <D.28022>:
    D.27993 = ctx->level;
    D.27994 = D.27993 & 128;
    if (D.27994 != 0) goto <D.28020>; else goto <D.28021>;
    <D.28020>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 8;
      D.27961 = ctx->ip_offset;
      D.28023 = monoeg_g_strdup_printf ("Cannot use ldvirtftn with a constructor at 0x%04x", D.27961);
      vinfo->info.message = D.28023;
      vinfo->exception_type = 4;
      D.27963 = ctx->list;
      D.28024 = monoeg_g_slist_prepend (D.27963, vinfo);
      ctx->list = D.28024;
    }
    ctx->verifiable = 0;
    D.27993 = ctx->level;
    D.27997 = D.27993 & 16;
    if (D.27997 != 0) goto <D.28025>; else goto <D.28026>;
    <D.28025>:
    ctx->valid = 0;
    <D.28026>:
    <D.28021>:
    <D.28019>:
    D.28027 = method->klass;
    D.28028 = &D.28027->byval_arg;
    D.28029 = verify_stack_type_compatibility (ctx, D.28028, top);
    if (D.28029 == 0) goto <D.28030>; else goto <D.28031>;
    <D.28030>:
    D.27991 = ctx->verifiable;
    if (D.27991 != 0) goto <D.28032>; else goto <D.28034>;
    <D.28034>:
    D.27993 = ctx->level;
    D.27994 = D.27993 & 128;
    if (D.27994 != 0) goto <D.28032>; else goto <D.28033>;
    <D.28032>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 8;
      D.27961 = ctx->ip_offset;
      D.28035 = monoeg_g_strdup_printf ("Unexpected object for ldvirtftn at 0x%04x", D.27961);
      vinfo->info.message = D.28035;
      vinfo->exception_type = 4;
      D.27963 = ctx->list;
      D.28036 = monoeg_g_slist_prepend (D.27963, vinfo);
      ctx->list = D.28036;
    }
    ctx->verifiable = 0;
    D.27993 = ctx->level;
    D.27997 = D.27993 & 16;
    if (D.27997 != 0) goto <D.28037>; else goto <D.28038>;
    <D.28037>:
    ctx->valid = 0;
    <D.28038>:
    <D.28033>:
    <D.28031>:
  }
  <D.28001>:
  D.27993 = ctx->level;
  D.28039 = D.27993 & 64;
  if (D.28039 == 0) goto <D.28040>; else goto <D.28041>;
  <D.28040>:
  D.27954 = ctx->method;
  D.28042 = mono_method_can_access_method_full (D.27954, method, 0B);
  if (D.28042 == 0) goto <D.28043>; else goto <D.28044>;
  <D.28043>:
  D.27991 = ctx->verifiable;
  if (D.27991 != 0) goto <D.28045>; else goto <D.28047>;
  <D.28047>:
  D.27993 = ctx->level;
  D.27994 = D.27993 & 128;
  if (D.27994 != 0) goto <D.28045>; else goto <D.28046>;
  <D.28045>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.27961 = ctx->ip_offset;
    D.28048 = monoeg_g_strdup_printf ("Loaded method is not visible for ldftn/ldvirtftn at 0x%04x", D.27961);
    vinfo->info.message = D.28048;
    vinfo->exception_type = 9;
    D.27963 = ctx->list;
    D.28049 = monoeg_g_slist_prepend (D.27963, vinfo);
    ctx->list = D.28049;
  }
  ctx->verifiable = 0;
  D.27993 = ctx->level;
  D.27997 = D.27993 & 16;
  if (D.27997 != 0) goto <D.28050>; else goto <D.28051>;
  <D.28050>:
  ctx->valid = 0;
  <D.28051>:
  <D.28046>:
  <D.28044>:
  <D.28041>:
  D.28052 = mono_type_create_fnptr_from_mono_method (ctx, method);
  top = stack_push_val (ctx, 5, D.28052);
  top->method = method;
}


mono_type_create_fnptr_from_mono_method (struct VerifyContext * ctx, struct MonoMethod * method)
{
  struct MonoMethodSignature * D.28054;
  struct GSList * D.28055;
  struct GSList * D.28056;
  struct MonoType * D.28057;
  struct MonoType * res;

  res = monoeg_malloc0 (8);
  D.28054 = mono_method_signature (method);
  res->data.method = D.28054;
  res->type = 27;
  D.28055 = ctx->funptrs;
  D.28056 = monoeg_g_slist_prepend (D.28055, res);
  ctx->funptrs = D.28056;
  D.28057 = res;
  return D.28057;
}


push_arg (struct VerifyContext * ctx, unsigned int arg, int take_addr)
{
  int D.28059;
  unsigned int D.28060;
  unsigned int D.28065;
  gchar * D.28066;
  struct GSList * D.28067;
  struct GSList * D.28068;
  int D.28072;
  int D.28074;
  int D.28075;
  gchar * D.28076;
  struct GSList * D.28077;
  int D.28078;
  int D.28081;
  struct MonoClass * D.28084;
  struct MonoType * D.28085;
  int D.28087;
  struct MonoType * * D.28090;
  unsigned int D.28091;
  struct MonoType * * D.28092;
  struct MonoType * D.28093;
  unsigned char D.28094;
  unsigned char D.28095;
  unsigned int D.28103;
  gchar * D.28104;
  struct GSList * D.28105;
  int D.28108;
  struct MonoMethod * D.28113;
  short unsigned int D.28114;
  int D.28115;
  int D.28116;
  int D.28122;
  int D.28123;
  int D.28124;
  int D.28127;
  struct MonoClass * D.28130;
  unsigned char D.28131;
  unsigned char D.28132;
  int D.28135;
  struct ILStackDesc * top;

  D.28059 = ctx->max_args;
  D.28060 = (unsigned int) D.28059;
  if (D.28060 <= arg) goto <D.28061>; else goto <D.28062>;
  <D.28061>:
  if (take_addr != 0) goto <D.28063>; else goto <D.28064>;
  <D.28063>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.28065 = arg + 1;
    D.28066 = monoeg_g_strdup_printf ("Method doesn\'t have argument %d", D.28065);
    vinfo->info.message = D.28066;
    vinfo->exception_type = 3;
    D.28067 = ctx->list;
    D.28068 = monoeg_g_slist_prepend (D.28067, vinfo);
    ctx->list = D.28068;
  }
  ctx->valid = 0;
  goto <D.28069>;
  <D.28064>:
  D.28072 = ctx->verifiable;
  if (D.28072 != 0) goto <D.28070>; else goto <D.28073>;
  <D.28073>:
  D.28074 = ctx->level;
  D.28075 = D.28074 & 128;
  if (D.28075 != 0) goto <D.28070>; else goto <D.28071>;
  <D.28070>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.28065 = arg + 1;
    D.28076 = monoeg_g_strdup_printf ("Method doesn\'t have argument %d", D.28065);
    vinfo->info.message = D.28076;
    vinfo->exception_type = 4;
    D.28067 = ctx->list;
    D.28077 = monoeg_g_slist_prepend (D.28067, vinfo);
    ctx->list = D.28077;
  }
  ctx->verifiable = 0;
  D.28074 = ctx->level;
  D.28078 = D.28074 & 16;
  if (D.28078 != 0) goto <D.28079>; else goto <D.28080>;
  <D.28079>:
  ctx->valid = 0;
  <D.28080>:
  <D.28071>:
  D.28081 = check_overflow (ctx);
  if (D.28081 != 0) goto <D.28082>; else goto <D.28083>;
  <D.28082>:
  D.28084 = mono_defaults.int32_class;
  D.28085 = &D.28084->byval_arg;
  stack_push_val (ctx, 1, D.28085);
  <D.28083>:
  <D.28069>:
  goto <D.28086>;
  <D.28062>:
  D.28087 = check_overflow (ctx);
  if (D.28087 != 0) goto <D.28088>; else goto <D.28089>;
  <D.28088>:
  D.28090 = ctx->params;
  D.28091 = arg * 4;
  D.28092 = D.28090 + D.28091;
  D.28093 = *D.28092;
  check_unverifiable_type (ctx, D.28093);
  D.28090 = ctx->params;
  D.28091 = arg * 4;
  D.28092 = D.28090 + D.28091;
  D.28093 = *D.28092;
  D.28094 = BIT_FIELD_REF <*D.28093, 8, 56>;
  D.28095 = D.28094 & 64;
  if (D.28095 != 0) goto <D.28096>; else goto <D.28097>;
  <D.28096>:
  if (take_addr != 0) goto <D.28098>; else goto <D.28099>;
  <D.28098>:
  D.28072 = ctx->verifiable;
  if (D.28072 != 0) goto <D.28100>; else goto <D.28102>;
  <D.28102>:
  D.28074 = ctx->level;
  D.28075 = D.28074 & 128;
  if (D.28075 != 0) goto <D.28100>; else goto <D.28101>;
  <D.28100>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.28103 = ctx->ip_offset;
    D.28104 = monoeg_g_strdup_printf ("ByRef of ByRef at 0x%04x", D.28103);
    vinfo->info.message = D.28104;
    vinfo->exception_type = 4;
    D.28067 = ctx->list;
    D.28105 = monoeg_g_slist_prepend (D.28067, vinfo);
    ctx->list = D.28105;
  }
  ctx->verifiable = 0;
  D.28074 = ctx->level;
  D.28078 = D.28074 & 16;
  if (D.28078 != 0) goto <D.28106>; else goto <D.28107>;
  <D.28106>:
  ctx->valid = 0;
  <D.28107>:
  <D.28101>:
  <D.28099>:
  <D.28097>:
  top = stack_push (ctx);
  D.28090 = ctx->params;
  D.28091 = arg * 4;
  D.28092 = D.28090 + D.28091;
  D.28093 = *D.28092;
  D.28108 = set_stack_value (ctx, top, D.28093, take_addr);
  if (D.28108 == 0) goto <D.28109>; else goto <D.28110>;
  <D.28109>:
  return;
  <D.28110>:
  if (arg == 0) goto <D.28111>; else goto <D.28112>;
  <D.28111>:
  D.28113 = ctx->method;
  D.28114 = D.28113->flags;
  D.28115 = (int) D.28114;
  D.28116 = D.28115 & 16;
  if (D.28116 == 0) goto <D.28117>; else goto <D.28118>;
  <D.28117>:
  if (take_addr != 0) goto <D.28119>; else goto <D.28120>;
  <D.28119>:
  ctx->has_this_store = 1;
  goto <D.28121>;
  <D.28120>:
  D.28122 = top->stype;
  D.28123 = D.28122 | 2048;
  top->stype = D.28123;
  <D.28121>:
  D.28113 = ctx->method;
  D.28124 = mono_method_is_constructor (D.28113);
  if (D.28124 != 0) goto <D.28125>; else goto <D.28126>;
  <D.28125>:
  D.28127 = ctx->super_ctor_called;
  if (D.28127 == 0) goto <D.28128>; else goto <D.28129>;
  <D.28128>:
  D.28113 = ctx->method;
  D.28130 = D.28113->klass;
  D.28131 = BIT_FIELD_REF <*D.28130, 8, 160>;
  D.28132 = D.28131 & 8;
  if (D.28132 == 0) goto <D.28133>; else goto <D.28134>;
  <D.28133>:
  D.28122 = top->stype;
  D.28135 = D.28122 | 8192;
  top->stype = D.28135;
  <D.28134>:
  <D.28129>:
  <D.28126>:
  <D.28118>:
  <D.28112>:
  <D.28089>:
  <D.28086>:
}


check_unverifiable_type (struct VerifyContext * ctx, struct MonoType * type)
{
  unsigned char D.28137;
  _Bool D.28138;
  _Bool D.28139;
  _Bool D.28140;
  int D.28145;
  int D.28147;
  int D.28148;
  unsigned int D.28149;
  gchar * D.28150;
  struct GSList * D.28151;
  struct GSList * D.28152;
  int D.28153;
  gboolean D.28156;

  D.28137 = type->type;
  D.28138 = D.28137 == 15;
  D.28139 = D.28137 == 27;
  D.28140 = D.28138 | D.28139;
  if (D.28140 != 0) goto <D.28141>; else goto <D.28142>;
  <D.28141>:
  D.28145 = ctx->verifiable;
  if (D.28145 != 0) goto <D.28143>; else goto <D.28146>;
  <D.28146>:
  D.28147 = ctx->level;
  D.28148 = D.28147 & 128;
  if (D.28148 != 0) goto <D.28143>; else goto <D.28144>;
  <D.28143>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.28149 = ctx->ip_offset;
    D.28150 = monoeg_g_strdup_printf ("Unmanaged pointer is not a verifiable type at 0x%04x", D.28149);
    vinfo->info.message = D.28150;
    vinfo->exception_type = 4;
    D.28151 = ctx->list;
    D.28152 = monoeg_g_slist_prepend (D.28151, vinfo);
    ctx->list = D.28152;
  }
  ctx->verifiable = 0;
  D.28147 = ctx->level;
  D.28153 = D.28147 & 16;
  if (D.28153 != 0) goto <D.28154>; else goto <D.28155>;
  <D.28154>:
  ctx->valid = 0;
  <D.28155>:
  <D.28144>:
  D.28156 = 0;
  return D.28156;
  <D.28142>:
  D.28156 = 1;
  return D.28156;
}


push_local (struct VerifyContext * ctx, guint32 arg, int take_addr)
{
  int D.28158;
  unsigned int D.28159;
  unsigned int D.28162;
  gchar * D.28163;
  struct GSList * D.28164;
  struct GSList * D.28165;
  int D.28167;
  struct MonoType * * D.28170;
  unsigned int D.28171;
  struct MonoType * * D.28172;
  struct MonoType * D.28173;
  unsigned char D.28174;
  unsigned char D.28175;
  int D.28182;
  int D.28184;
  int D.28185;
  unsigned int D.28186;
  gchar * D.28187;
  struct GSList * D.28188;
  int D.28189;
  struct ILStackDesc * D.28192;

  D.28158 = ctx->num_locals;
  D.28159 = (unsigned int) D.28158;
  if (D.28159 <= arg) goto <D.28160>; else goto <D.28161>;
  <D.28160>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.28162 = arg + 1;
    D.28163 = monoeg_g_strdup_printf ("Method doesn\'t have local %d", D.28162);
    vinfo->info.message = D.28163;
    vinfo->exception_type = 3;
    D.28164 = ctx->list;
    D.28165 = monoeg_g_slist_prepend (D.28164, vinfo);
    ctx->list = D.28165;
  }
  ctx->valid = 0;
  goto <D.28166>;
  <D.28161>:
  D.28167 = check_overflow (ctx);
  if (D.28167 != 0) goto <D.28168>; else goto <D.28169>;
  <D.28168>:
  D.28170 = ctx->locals;
  D.28171 = arg * 4;
  D.28172 = D.28170 + D.28171;
  D.28173 = *D.28172;
  check_unverifiable_type (ctx, D.28173);
  D.28170 = ctx->locals;
  D.28171 = arg * 4;
  D.28172 = D.28170 + D.28171;
  D.28173 = *D.28172;
  D.28174 = BIT_FIELD_REF <*D.28173, 8, 56>;
  D.28175 = D.28174 & 64;
  if (D.28175 != 0) goto <D.28176>; else goto <D.28177>;
  <D.28176>:
  if (take_addr != 0) goto <D.28178>; else goto <D.28179>;
  <D.28178>:
  D.28182 = ctx->verifiable;
  if (D.28182 != 0) goto <D.28180>; else goto <D.28183>;
  <D.28183>:
  D.28184 = ctx->level;
  D.28185 = D.28184 & 128;
  if (D.28185 != 0) goto <D.28180>; else goto <D.28181>;
  <D.28180>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.28186 = ctx->ip_offset;
    D.28187 = monoeg_g_strdup_printf ("ByRef of ByRef at 0x%04x", D.28186);
    vinfo->info.message = D.28187;
    vinfo->exception_type = 4;
    D.28164 = ctx->list;
    D.28188 = monoeg_g_slist_prepend (D.28164, vinfo);
    ctx->list = D.28188;
  }
  ctx->verifiable = 0;
  D.28184 = ctx->level;
  D.28189 = D.28184 & 16;
  if (D.28189 != 0) goto <D.28190>; else goto <D.28191>;
  <D.28190>:
  ctx->valid = 0;
  <D.28191>:
  <D.28181>:
  <D.28179>:
  <D.28177>:
  D.28192 = stack_push (ctx);
  D.28170 = ctx->locals;
  D.28171 = arg * 4;
  D.28172 = D.28170 + D.28171;
  D.28173 = *D.28172;
  set_stack_value (ctx, D.28192, D.28173, take_addr);
  <D.28169>:
  <D.28166>:
}


do_localloc (struct VerifyContext * ctx)
{
  short unsigned int D.28193;
  unsigned int D.28196;
  gchar * D.28197;
  struct GSList * D.28198;
  struct GSList * D.28199;
  struct MonoMethodHeader * D.28200;
  int D.28201;
  gchar * D.28204;
  struct GSList * D.28205;
  struct ILStackDesc * D.28206;
  struct MonoClass * D.28207;
  struct MonoType * D.28208;
  int D.28211;
  int D.28213;
  int D.28214;
  gchar * D.28215;
  struct GSList * D.28216;
  int D.28217;
  struct ILStackDesc * top;

  D.28193 = ctx->eval.size;
  if (D.28193 != 1) goto <D.28194>; else goto <D.28195>;
  <D.28194>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.28196 = ctx->ip_offset;
    D.28197 = monoeg_g_strdup_printf ("Stack must have only size item in localloc at 0x%04x", D.28196);
    vinfo->info.message = D.28197;
    vinfo->exception_type = 3;
    D.28198 = ctx->list;
    D.28199 = monoeg_g_slist_prepend (D.28198, vinfo);
    ctx->list = D.28199;
  }
  ctx->valid = 0;
  return;
  <D.28195>:
  D.28200 = ctx->header;
  D.28196 = ctx->ip_offset;
  D.28201 = in_any_exception_block (D.28200, D.28196);
  if (D.28201 != 0) goto <D.28202>; else goto <D.28203>;
  <D.28202>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.28196 = ctx->ip_offset;
    D.28204 = monoeg_g_strdup_printf ("Stack must have only size item in localloc at 0x%04x", D.28196);
    vinfo->info.message = D.28204;
    vinfo->exception_type = 3;
    D.28198 = ctx->list;
    D.28205 = monoeg_g_slist_prepend (D.28198, vinfo);
    ctx->list = D.28205;
  }
  ctx->valid = 0;
  return;
  <D.28203>:
  top = stack_pop (ctx);
  D.28206 = stack_push (ctx);
  D.28207 = mono_defaults.int_class;
  D.28208 = &D.28207->byval_arg;
  set_stack_value (ctx, D.28206, D.28208, 0);
  D.28211 = ctx->verifiable;
  if (D.28211 != 0) goto <D.28209>; else goto <D.28212>;
  <D.28212>:
  D.28213 = ctx->level;
  D.28214 = D.28213 & 128;
  if (D.28214 != 0) goto <D.28209>; else goto <D.28210>;
  <D.28209>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.28196 = ctx->ip_offset;
    D.28215 = monoeg_g_strdup_printf ("Instruction localloc in never verifiable at 0x%04x", D.28196);
    vinfo->info.message = D.28215;
    vinfo->exception_type = 4;
    D.28198 = ctx->list;
    D.28216 = monoeg_g_slist_prepend (D.28198, vinfo);
    ctx->list = D.28216;
  }
  ctx->verifiable = 0;
  D.28213 = ctx->level;
  D.28217 = D.28213 & 16;
  if (D.28217 != 0) goto <D.28218>; else goto <D.28219>;
  <D.28218>:
  ctx->valid = 0;
  <D.28219>:
  <D.28210>:
}


in_any_exception_block (struct MonoMethodHeader * header, guint offset)
{
  struct MonoExceptionClause * D.28221;
  unsigned int i.125;
  unsigned int D.28223;
  unsigned int D.28224;
  unsigned int D.28227;
  unsigned int D.28228;
  gboolean D.28231;
  unsigned int D.28232;
  unsigned int D.28235;
  <unnamed-unsigned:15> D.28240;
  int D.28241;
  int i;
  struct MonoExceptionClause * clause;

  i = 0;
  goto <D.20383>;
  <D.20382>:
  D.28221 = header->clauses;
  i.125 = (unsigned int) i;
  D.28223 = i.125 * 24;
  clause = D.28221 + D.28223;
  D.28224 = clause->handler_offset;
  if (D.28224 <= offset) goto <D.28225>; else goto <D.28226>;
  <D.28225>:
  D.28224 = clause->handler_offset;
  D.28227 = clause->handler_len;
  D.28228 = D.28224 + D.28227;
  if (D.28228 > offset) goto <D.28229>; else goto <D.28230>;
  <D.28229>:
  D.28231 = 1;
  return D.28231;
  <D.28230>:
  <D.28226>:
  D.28232 = clause->flags;
  if (D.28232 == 1) goto <D.28233>; else goto <D.28234>;
  <D.28233>:
  D.28235 = clause->data.filter_offset;
  if (D.28235 <= offset) goto <D.28236>; else goto <D.28237>;
  <D.28236>:
  D.28224 = clause->handler_offset;
  if (D.28224 > offset) goto <D.28238>; else goto <D.28239>;
  <D.28238>:
  D.28231 = 1;
  return D.28231;
  <D.28239>:
  <D.28237>:
  <D.28234>:
  i = i + 1;
  <D.20383>:
  D.28240 = header->num_clauses;
  D.28241 = (int) D.28240;
  if (D.28241 > i) goto <D.20382>; else goto <D.20384>;
  <D.20384>:
  D.28231 = 0;
  return D.28231;
}


do_endfilter (struct VerifyContext * ctx)
{
  int D.28243;
  int D.28244;
  short unsigned int D.28247;
  int D.28252;
  int D.28254;
  unsigned int D.28255;
  gchar * D.28256;
  struct GSList * D.28257;
  struct GSList * D.28258;
  int D.28259;
  struct ILStackDesc * D.28264;
  int D.28265;
  gchar * D.28271;
  struct GSList * D.28272;
  unsigned int D.28279;
  unsigned int D.28280;
  gchar * D.28283;
  struct GSList * D.28284;
  unsigned int D.28291;
  unsigned int D.28292;
  gchar * D.28293;
  struct GSList * D.28294;
  int D.28299;
  gchar * D.28301;
  struct GSList * D.28302;
  gchar * D.28306;
  struct GSList * D.28307;
  struct MonoExceptionClause * clause;

  D.28243 = ctx->level;
  D.28244 = D.28243 & 32;
  if (D.28244 == 0) goto <D.28245>; else goto <D.28246>;
  <D.28245>:
  D.28247 = ctx->eval.size;
  if (D.28247 != 1) goto <D.28248>; else goto <D.28249>;
  <D.28248>:
  D.28252 = ctx->verifiable;
  if (D.28252 != 0) goto <D.28250>; else goto <D.28253>;
  <D.28253>:
  D.28243 = ctx->level;
  D.28254 = D.28243 & 128;
  if (D.28254 != 0) goto <D.28250>; else goto <D.28251>;
  <D.28250>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.28255 = ctx->ip_offset;
    D.28256 = monoeg_g_strdup_printf ("Stack size must have one item for endfilter at 0x%04x", D.28255);
    vinfo->info.message = D.28256;
    vinfo->exception_type = 4;
    D.28257 = ctx->list;
    D.28258 = monoeg_g_slist_prepend (D.28257, vinfo);
    ctx->list = D.28258;
  }
  ctx->verifiable = 0;
  D.28243 = ctx->level;
  D.28259 = D.28243 & 16;
  if (D.28259 != 0) goto <D.28260>; else goto <D.28261>;
  <D.28260>:
  ctx->valid = 0;
  <D.28261>:
  <D.28251>:
  <D.28249>:
  D.28247 = ctx->eval.size;
  if (D.28247 != 0) goto <D.28262>; else goto <D.28263>;
  <D.28262>:
  D.28264 = stack_pop (ctx);
  D.28265 = stack_slot_get_type (D.28264);
  if (D.28265 != 1) goto <D.28266>; else goto <D.28267>;
  <D.28266>:
  D.28252 = ctx->verifiable;
  if (D.28252 != 0) goto <D.28268>; else goto <D.28270>;
  <D.28270>:
  D.28243 = ctx->level;
  D.28254 = D.28243 & 128;
  if (D.28254 != 0) goto <D.28268>; else goto <D.28269>;
  <D.28268>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.28255 = ctx->ip_offset;
    D.28271 = monoeg_g_strdup_printf ("Stack item type is not an int32 for endfilter at 0x%04x", D.28255);
    vinfo->info.message = D.28271;
    vinfo->exception_type = 4;
    D.28257 = ctx->list;
    D.28272 = monoeg_g_slist_prepend (D.28257, vinfo);
    ctx->list = D.28272;
  }
  ctx->verifiable = 0;
  D.28243 = ctx->level;
  D.28259 = D.28243 & 16;
  if (D.28259 != 0) goto <D.28273>; else goto <D.28274>;
  <D.28273>:
  ctx->valid = 0;
  <D.28274>:
  <D.28269>:
  <D.28267>:
  <D.28263>:
  <D.28246>:
  D.28255 = ctx->ip_offset;
  clause = is_correct_endfilter (ctx, D.28255);
  if (clause != 0B) goto <D.28275>; else goto <D.28276>;
  <D.28275>:
  D.28243 = ctx->level;
  D.28244 = D.28243 & 32;
  if (D.28244 == 0) goto <D.28277>; else goto <D.28278>;
  <D.28277>:
  D.28255 = ctx->ip_offset;
  D.28279 = clause->handler_offset;
  D.28280 = D.28279 + 4294967294;
  if (D.28255 != D.28280) goto <D.28281>; else goto <D.28282>;
  <D.28281>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.28255 = ctx->ip_offset;
    D.28283 = monoeg_g_strdup_printf ("endfilter is not the last instruction of the filter clause at 0x%04x", D.28255);
    vinfo->info.message = D.28283;
    vinfo->exception_type = 3;
    D.28257 = ctx->list;
    D.28284 = monoeg_g_slist_prepend (D.28257, vinfo);
    ctx->list = D.28284;
  }
  ctx->valid = 0;
  <D.28282>:
  goto <D.28285>;
  <D.28278>:
  D.28255 = ctx->ip_offset;
  D.28279 = clause->handler_offset;
  D.28280 = D.28279 + 4294967294;
  if (D.28255 != D.28280) goto <D.28288>; else goto <D.28289>;
  <D.28288>:
  D.28279 = clause->handler_offset;
  D.28255 = ctx->ip_offset;
  if (D.28279 > D.28255) goto <D.28286>; else goto <D.28290>;
  <D.28290>:
  D.28255 = ctx->ip_offset;
  D.28279 = clause->handler_offset;
  D.28291 = clause->handler_len;
  D.28292 = D.28279 + D.28291;
  if (D.28255 >= D.28292) goto <D.28286>; else goto <D.28287>;
  <D.28286>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.28255 = ctx->ip_offset;
    D.28293 = monoeg_g_strdup_printf ("endfilter is not the last instruction of the filter clause at 0x%04x", D.28255);
    vinfo->info.message = D.28293;
    vinfo->exception_type = 3;
    D.28257 = ctx->list;
    D.28294 = monoeg_g_slist_prepend (D.28257, vinfo);
    ctx->list = D.28294;
  }
  ctx->valid = 0;
  <D.28287>:
  <D.28289>:
  <D.28285>:
  goto <D.28295>;
  <D.28276>:
  D.28243 = ctx->level;
  D.28244 = D.28243 & 32;
  if (D.28244 == 0) goto <D.28298>; else goto <D.28296>;
  <D.28298>:
  D.28255 = ctx->ip_offset;
  D.28299 = is_unverifiable_endfilter (ctx, D.28255);
  if (D.28299 == 0) goto <D.28300>; else goto <D.28296>;
  <D.28300>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.28255 = ctx->ip_offset;
    D.28301 = monoeg_g_strdup_printf ("endfilter outside filter clause at 0x%04x", D.28255);
    vinfo->info.message = D.28301;
    vinfo->exception_type = 3;
    D.28257 = ctx->list;
    D.28302 = monoeg_g_slist_prepend (D.28257, vinfo);
    ctx->list = D.28302;
  }
  ctx->valid = 0;
  goto <D.28297>;
  <D.28296>:
  D.28252 = ctx->verifiable;
  if (D.28252 != 0) goto <D.28303>; else goto <D.28305>;
  <D.28305>:
  D.28243 = ctx->level;
  D.28254 = D.28243 & 128;
  if (D.28254 != 0) goto <D.28303>; else goto <D.28304>;
  <D.28303>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.28255 = ctx->ip_offset;
    D.28306 = monoeg_g_strdup_printf ("endfilter outside filter clause at 0x%04x", D.28255);
    vinfo->info.message = D.28306;
    vinfo->exception_type = 4;
    D.28257 = ctx->list;
    D.28307 = monoeg_g_slist_prepend (D.28257, vinfo);
    ctx->list = D.28307;
  }
  ctx->verifiable = 0;
  D.28243 = ctx->level;
  D.28259 = D.28243 & 16;
  if (D.28259 != 0) goto <D.28308>; else goto <D.28309>;
  <D.28308>:
  ctx->valid = 0;
  <D.28309>:
  <D.28304>:
  <D.28297>:
  <D.28295>:
  ctx->eval.size = 0;
}


is_correct_endfilter (struct VerifyContext * ctx, guint offset)
{
  struct MonoMethodHeader * D.28310;
  struct MonoExceptionClause * D.28311;
  unsigned int i.126;
  unsigned int D.28313;
  unsigned int D.28314;
  unsigned int D.28319;
  unsigned int D.28322;
  struct MonoExceptionClause * D.28325;
  int D.28326;
  int D.28327;
  unsigned int D.28332;
  unsigned int D.28333;
  <unnamed-unsigned:15> D.28336;
  int D.28337;
  int i;
  struct MonoExceptionClause * clause;

  i = 0;
  goto <D.20441>;
  <D.20440>:
  D.28310 = ctx->header;
  D.28311 = D.28310->clauses;
  i.126 = (unsigned int) i;
  D.28313 = i.126 * 24;
  clause = D.28311 + D.28313;
  D.28314 = clause->flags;
  if (D.28314 != 1) goto <D.28315>; else goto <D.28316>;
  <D.28315>:
  // predicted unlikely by continue predictor.
  goto <D.20439>;
  <D.28316>:
  D.28314 = clause->flags;
  if (D.28314 == 1) goto <D.28317>; else goto <D.28318>;
  <D.28317>:
  D.28319 = clause->data.filter_offset;
  if (D.28319 <= offset) goto <D.28320>; else goto <D.28321>;
  <D.28320>:
  D.28322 = clause->handler_offset;
  if (D.28322 > offset) goto <D.28323>; else goto <D.28324>;
  <D.28323>:
  D.28325 = clause;
  return D.28325;
  <D.28324>:
  <D.28321>:
  <D.28318>:
  D.28326 = ctx->level;
  D.28327 = D.28326 & 32;
  if (D.28327 != 0) goto <D.28328>; else goto <D.28329>;
  <D.28328>:
  D.28322 = clause->handler_offset;
  if (D.28322 <= offset) goto <D.28330>; else goto <D.28331>;
  <D.28330>:
  D.28322 = clause->handler_offset;
  D.28332 = clause->handler_len;
  D.28333 = D.28322 + D.28332;
  if (D.28333 > offset) goto <D.28334>; else goto <D.28335>;
  <D.28334>:
  D.28325 = clause;
  return D.28325;
  <D.28335>:
  <D.28331>:
  <D.28329>:
  <D.20439>:
  i = i + 1;
  <D.20441>:
  D.28310 = ctx->header;
  D.28336 = D.28310->num_clauses;
  D.28337 = (int) D.28336;
  if (D.28337 > i) goto <D.20440>; else goto <D.20442>;
  <D.20442>:
  D.28325 = 0B;
  return D.28325;
}


is_unverifiable_endfilter (struct VerifyContext * ctx, guint offset)
{
  struct MonoMethodHeader * D.28339;
  struct MonoExceptionClause * D.28340;
  unsigned int i.127;
  unsigned int D.28342;
  unsigned int D.28343;
  unsigned int D.28346;
  unsigned int D.28347;
  int D.28350;
  <unnamed-unsigned:15> D.28351;
  int D.28352;
  int i;
  struct MonoExceptionClause * clause;

  i = 0;
  goto <D.20450>;
  <D.20449>:
  D.28339 = ctx->header;
  D.28340 = D.28339->clauses;
  i.127 = (unsigned int) i;
  D.28342 = i.127 * 24;
  clause = D.28340 + D.28342;
  D.28343 = clause->try_offset;
  if (D.28343 <= offset) goto <D.28344>; else goto <D.28345>;
  <D.28344>:
  D.28343 = clause->try_offset;
  D.28346 = clause->try_len;
  D.28347 = D.28343 + D.28346;
  if (D.28347 > offset) goto <D.28348>; else goto <D.28349>;
  <D.28348>:
  D.28350 = 1;
  return D.28350;
  <D.28349>:
  <D.28345>:
  i = i + 1;
  <D.20450>:
  D.28339 = ctx->header;
  D.28351 = D.28339->num_clauses;
  D.28352 = (int) D.28351;
  if (D.28352 > i) goto <D.20449>; else goto <D.20451>;
  <D.20451>:
  D.28350 = 0;
  return D.28350;
}


do_initobj (struct VerifyContext * ctx, int token)
{
  int D.28356;
  int D.28359;
  int D.28364;
  int D.28366;
  int D.28367;
  unsigned int D.28368;
  gchar * D.28369;
  struct GSList * D.28370;
  struct GSList * D.28371;
  int D.28372;
  int D.28375;
  gchar * D.28381;
  struct GSList * D.28382;
  struct MonoType * D.28385;
  int D.28386;
  int D.28389;
  gchar * D.28395;
  struct GSList * D.28396;
  int D.28400;
  int D.28403;
  gchar * D.28409;
  struct GSList * D.28410;
  int D.28414;
  gchar * D.28420;
  struct GSList * D.28421;
  struct ILStackDesc * obj;
  struct MonoType * stack;
  struct MonoType * type;

  type = get_boxable_mono_type (ctx, token, "initobj");
  if (type == 0B) goto <D.28354>; else goto <D.28355>;
  <D.28354>:
  return;
  <D.28355>:
  D.28356 = check_underflow (ctx, 1);
  if (D.28356 == 0) goto <D.28357>; else goto <D.28358>;
  <D.28357>:
  return;
  <D.28358>:
  obj = stack_pop (ctx);
  D.28359 = stack_slot_is_managed_pointer (obj);
  if (D.28359 == 0) goto <D.28360>; else goto <D.28361>;
  <D.28360>:
  D.28364 = ctx->verifiable;
  if (D.28364 != 0) goto <D.28362>; else goto <D.28365>;
  <D.28365>:
  D.28366 = ctx->level;
  D.28367 = D.28366 & 128;
  if (D.28367 != 0) goto <D.28362>; else goto <D.28363>;
  <D.28362>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.28368 = ctx->ip_offset;
    D.28369 = monoeg_g_strdup_printf ("Invalid object address for initobj at 0x%04x", D.28368);
    vinfo->info.message = D.28369;
    vinfo->exception_type = 4;
    D.28370 = ctx->list;
    D.28371 = monoeg_g_slist_prepend (D.28370, vinfo);
    ctx->list = D.28371;
  }
  ctx->verifiable = 0;
  D.28366 = ctx->level;
  D.28372 = D.28366 & 16;
  if (D.28372 != 0) goto <D.28373>; else goto <D.28374>;
  <D.28373>:
  ctx->valid = 0;
  <D.28374>:
  <D.28363>:
  <D.28361>:
  D.28375 = stack_slot_is_managed_mutability_pointer (obj);
  if (D.28375 != 0) goto <D.28376>; else goto <D.28377>;
  <D.28376>:
  D.28364 = ctx->verifiable;
  if (D.28364 != 0) goto <D.28378>; else goto <D.28380>;
  <D.28380>:
  D.28366 = ctx->level;
  D.28367 = D.28366 & 128;
  if (D.28367 != 0) goto <D.28378>; else goto <D.28379>;
  <D.28378>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.28368 = ctx->ip_offset;
    D.28381 = monoeg_g_strdup_printf ("Cannot use a readonly pointer with initobj at 0x%04x", D.28368);
    vinfo->info.message = D.28381;
    vinfo->exception_type = 4;
    D.28370 = ctx->list;
    D.28382 = monoeg_g_slist_prepend (D.28370, vinfo);
    ctx->list = D.28382;
  }
  ctx->verifiable = 0;
  D.28366 = ctx->level;
  D.28372 = D.28366 & 16;
  if (D.28372 != 0) goto <D.28383>; else goto <D.28384>;
  <D.28383>:
  ctx->valid = 0;
  <D.28384>:
  <D.28379>:
  <D.28377>:
  D.28385 = obj->type;
  stack = mono_type_get_type_byval (D.28385);
  D.28386 = mono_type_is_reference (stack);
  if (D.28386 != 0) goto <D.28387>; else goto <D.28388>;
  <D.28387>:
  D.28389 = verify_type_compatibility (ctx, stack, type);
  if (D.28389 == 0) goto <D.28390>; else goto <D.28391>;
  <D.28390>:
  D.28364 = ctx->verifiable;
  if (D.28364 != 0) goto <D.28392>; else goto <D.28394>;
  <D.28394>:
  D.28366 = ctx->level;
  D.28367 = D.28366 & 128;
  if (D.28367 != 0) goto <D.28392>; else goto <D.28393>;
  <D.28392>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.28368 = ctx->ip_offset;
    D.28395 = monoeg_g_strdup_printf ("Type token of initobj not compatible with value on stack at 0x%04x", D.28368);
    vinfo->info.message = D.28395;
    vinfo->exception_type = 4;
    D.28370 = ctx->list;
    D.28396 = monoeg_g_slist_prepend (D.28370, vinfo);
    ctx->list = D.28396;
  }
  ctx->verifiable = 0;
  D.28366 = ctx->level;
  D.28372 = D.28366 & 16;
  if (D.28372 != 0) goto <D.28397>; else goto <D.28398>;
  <D.28397>:
  ctx->valid = 0;
  <D.28398>:
  <D.28393>:
  goto <D.28399>;
  <D.28391>:
  D.28366 = ctx->level;
  D.28400 = D.28366 & 32;
  if (D.28400 == 0) goto <D.28401>; else goto <D.28402>;
  <D.28401>:
  D.28403 = mono_metadata_type_equal (type, stack);
  if (D.28403 == 0) goto <D.28404>; else goto <D.28405>;
  <D.28404>:
  D.28364 = ctx->verifiable;
  if (D.28364 != 0) goto <D.28406>; else goto <D.28408>;
  <D.28408>:
  D.28366 = ctx->level;
  D.28367 = D.28366 & 128;
  if (D.28367 != 0) goto <D.28406>; else goto <D.28407>;
  <D.28406>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.28368 = ctx->ip_offset;
    D.28409 = monoeg_g_strdup_printf ("Type token of initobj not compatible with value on stack at 0x%04x", D.28368);
    vinfo->info.message = D.28409;
    vinfo->exception_type = 4;
    D.28370 = ctx->list;
    D.28410 = monoeg_g_slist_prepend (D.28370, vinfo);
    ctx->list = D.28410;
  }
  ctx->verifiable = 0;
  D.28366 = ctx->level;
  D.28372 = D.28366 & 16;
  if (D.28372 != 0) goto <D.28411>; else goto <D.28412>;
  <D.28411>:
  ctx->valid = 0;
  <D.28412>:
  <D.28407>:
  <D.28405>:
  <D.28402>:
  <D.28399>:
  goto <D.28413>;
  <D.28388>:
  D.28414 = verify_type_compatibility (ctx, stack, type);
  if (D.28414 == 0) goto <D.28415>; else goto <D.28416>;
  <D.28415>:
  {
    char * expected_name;
    char * stack_name;

    expected_name = mono_type_full_name (type);
    stack_name = mono_type_full_name (stack);
    D.28364 = ctx->verifiable;
    if (D.28364 != 0) goto <D.28417>; else goto <D.28419>;
    <D.28419>:
    D.28366 = ctx->level;
    D.28367 = D.28366 & 128;
    if (D.28367 != 0) goto <D.28417>; else goto <D.28418>;
    <D.28417>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 8;
      D.28368 = ctx->ip_offset;
      D.28420 = monoeg_g_strdup_printf ("Initobj %s not compatible with value on stack %s at 0x%04x", expected_name, stack_name, D.28368);
      vinfo->info.message = D.28420;
      vinfo->exception_type = 4;
      D.28370 = ctx->list;
      D.28421 = monoeg_g_slist_prepend (D.28370, vinfo);
      ctx->list = D.28421;
    }
    ctx->verifiable = 0;
    D.28366 = ctx->level;
    D.28372 = D.28366 & 16;
    if (D.28372 != 0) goto <D.28422>; else goto <D.28423>;
    <D.28422>:
    ctx->valid = 0;
    <D.28423>:
    <D.28418>:
    monoeg_g_free (expected_name);
    monoeg_g_free (stack_name);
  }
  <D.28416>:
  <D.28413>:
}


get_boxable_mono_type (struct VerifyContext * ctx, int token, const char * opcode)
{
  struct MonoType * D.28427;
  unsigned char D.28428;
  unsigned char D.28429;
  unsigned char D.28432;
  unsigned int D.28435;
  gchar * D.28436;
  struct GSList * D.28437;
  struct GSList * D.28438;
  gchar * D.28441;
  struct GSList * D.28442;
  int D.28447;
  int D.28449;
  int D.28450;
  gchar * D.28451;
  struct GSList * D.28452;
  int D.28453;
  gchar * D.28458;
  struct GSList * D.28459;
  struct MonoGenericContainer * D.28460;
  gchar * D.28468;
  struct GSList * D.28469;
  struct MonoType * type;
  struct MonoClass * class;

  type = verifier_load_type (ctx, token, opcode);
  if (type == 0B) goto <D.28425>; else goto <D.28426>;
  <D.28425>:
  D.28427 = 0B;
  return D.28427;
  <D.28426>:
  D.28428 = BIT_FIELD_REF <*type, 8, 56>;
  D.28429 = D.28428 & 64;
  if (D.28429 != 0) goto <D.28430>; else goto <D.28431>;
  <D.28430>:
  D.28432 = type->type;
  if (D.28432 != 22) goto <D.28433>; else goto <D.28434>;
  <D.28433>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.28435 = ctx->ip_offset;
    D.28436 = monoeg_g_strdup_printf ("Invalid use of byref type for %s at 0x%04x", opcode, D.28435);
    vinfo->info.message = D.28436;
    vinfo->exception_type = 3;
    D.28437 = ctx->list;
    D.28438 = monoeg_g_slist_prepend (D.28437, vinfo);
    ctx->list = D.28438;
  }
  ctx->valid = 0;
  D.28427 = 0B;
  return D.28427;
  <D.28434>:
  <D.28431>:
  D.28432 = type->type;
  if (D.28432 == 1) goto <D.28439>; else goto <D.28440>;
  <D.28439>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.28435 = ctx->ip_offset;
    D.28441 = monoeg_g_strdup_printf ("Invalid use of void type for %s at 0x%04x", opcode, D.28435);
    vinfo->info.message = D.28441;
    vinfo->exception_type = 3;
    D.28437 = ctx->list;
    D.28442 = monoeg_g_slist_prepend (D.28437, vinfo);
    ctx->list = D.28442;
  }
  ctx->valid = 0;
  D.28427 = 0B;
  return D.28427;
  <D.28440>:
  D.28432 = type->type;
  if (D.28432 == 22) goto <D.28443>; else goto <D.28444>;
  <D.28443>:
  D.28447 = ctx->verifiable;
  if (D.28447 != 0) goto <D.28445>; else goto <D.28448>;
  <D.28448>:
  D.28449 = ctx->level;
  D.28450 = D.28449 & 128;
  if (D.28450 != 0) goto <D.28445>; else goto <D.28446>;
  <D.28445>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.28435 = ctx->ip_offset;
    D.28451 = monoeg_g_strdup_printf ("Invalid use of typedbyref for %s at 0x%04x", opcode, D.28435);
    vinfo->info.message = D.28451;
    vinfo->exception_type = 4;
    D.28437 = ctx->list;
    D.28452 = monoeg_g_slist_prepend (D.28437, vinfo);
    ctx->list = D.28452;
  }
  ctx->verifiable = 0;
  D.28449 = ctx->level;
  D.28453 = D.28449 & 16;
  if (D.28453 != 0) goto <D.28454>; else goto <D.28455>;
  <D.28454>:
  ctx->valid = 0;
  <D.28455>:
  <D.28446>:
  <D.28444>:
  class = mono_class_from_mono_type (type);
  if (class == 0B) goto <D.28456>; else goto <D.28457>;
  <D.28456>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.28435 = ctx->ip_offset;
    D.28458 = monoeg_g_strdup_printf ("Could not retrieve type token for %s at 0x%04x", opcode, D.28435);
    vinfo->info.message = D.28458;
    vinfo->exception_type = 3;
    D.28437 = ctx->list;
    D.28459 = monoeg_g_slist_prepend (D.28437, vinfo);
    ctx->list = D.28459;
  }
  ctx->valid = 0;
  <D.28457>:
  D.28460 = class->generic_container;
  if (D.28460 != 0B) goto <D.28461>; else goto <D.28462>;
  <D.28461>:
  D.28432 = type->type;
  if (D.28432 != 21) goto <D.28463>; else goto <D.28464>;
  <D.28463>:
  D.28447 = ctx->verifiable;
  if (D.28447 != 0) goto <D.28465>; else goto <D.28467>;
  <D.28467>:
  D.28449 = ctx->level;
  D.28450 = D.28449 & 128;
  if (D.28450 != 0) goto <D.28465>; else goto <D.28466>;
  <D.28465>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 8;
    D.28435 = ctx->ip_offset;
    D.28468 = monoeg_g_strdup_printf ("Cannot use the generic type definition in a boxable type position for %s at 0x%04x", opcode, D.28435);
    vinfo->info.message = D.28468;
    vinfo->exception_type = 4;
    D.28437 = ctx->list;
    D.28469 = monoeg_g_slist_prepend (D.28437, vinfo);
    ctx->list = D.28469;
  }
  ctx->verifiable = 0;
  D.28449 = ctx->level;
  D.28453 = D.28449 & 16;
  if (D.28453 != 0) goto <D.28470>; else goto <D.28471>;
  <D.28470>:
  ctx->valid = 0;
  <D.28471>:
  <D.28466>:
  <D.28464>:
  <D.28462>:
  check_unverifiable_type (ctx, type);
  D.28427 = type;
  return D.28427;
}


check_underflow (struct VerifyContext * ctx, int size)
{
  short unsigned int D.28473;
  int D.28474;
  unsigned int D.28477;
  gchar * D.28478;
  struct GSList * D.28479;
  struct GSList * D.28480;
  int D.28481;

  D.28473 = ctx->eval.size;
  D.28474 = (int) D.28473;
  if (D.28474 < size) goto <D.28475>; else goto <D.28476>;
  <D.28475>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.28473 = ctx->eval.size;
    D.28474 = (int) D.28473;
    D.28477 = ctx->ip_offset;
    D.28478 = monoeg_g_strdup_printf ("Stack underflow, required %d, but have %d at 0x%04x", size, D.28474, D.28477);
    vinfo->info.message = D.28478;
    vinfo->exception_type = 3;
    D.28479 = ctx->list;
    D.28480 = monoeg_g_slist_prepend (D.28479, vinfo);
    ctx->list = D.28480;
  }
  ctx->valid = 0;
  D.28481 = 0;
  return D.28481;
  <D.28476>:
  D.28481 = 1;
  return D.28481;
}


is_correct_rethrow (struct MonoMethodHeader * header, guint offset)
{
  struct MonoExceptionClause * D.28483;
  unsigned int i.128;
  unsigned int D.28485;
  unsigned int D.28486;
  unsigned int D.28489;
  unsigned int D.28490;
  int D.28493;
  unsigned int D.28494;
  unsigned int D.28497;
  <unnamed-unsigned:15> D.28502;
  int D.28503;
  int i;
  struct MonoExceptionClause * clause;

  i = 0;
  goto <D.20422>;
  <D.20421>:
  D.28483 = header->clauses;
  i.128 = (unsigned int) i;
  D.28485 = i.128 * 24;
  clause = D.28483 + D.28485;
  D.28486 = clause->handler_offset;
  if (D.28486 <= offset) goto <D.28487>; else goto <D.28488>;
  <D.28487>:
  D.28486 = clause->handler_offset;
  D.28489 = clause->handler_len;
  D.28490 = D.28486 + D.28489;
  if (D.28490 > offset) goto <D.28491>; else goto <D.28492>;
  <D.28491>:
  D.28493 = 1;
  return D.28493;
  <D.28492>:
  <D.28488>:
  D.28494 = clause->flags;
  if (D.28494 == 1) goto <D.28495>; else goto <D.28496>;
  <D.28495>:
  D.28497 = clause->data.filter_offset;
  if (D.28497 <= offset) goto <D.28498>; else goto <D.28499>;
  <D.28498>:
  D.28486 = clause->handler_offset;
  if (D.28486 > offset) goto <D.28500>; else goto <D.28501>;
  <D.28500>:
  D.28493 = 1;
  return D.28493;
  <D.28501>:
  <D.28499>:
  <D.28496>:
  i = i + 1;
  <D.20422>:
  D.28502 = header->num_clauses;
  D.28503 = (int) D.28502;
  if (D.28503 > i) goto <D.20421>; else goto <D.20423>;
  <D.20423>:
  D.28493 = 0;
  return D.28493;
}


do_sizeof (struct VerifyContext * ctx, int token)
{
  unsigned char D.28507;
  unsigned char D.28508;
  unsigned char D.28511;
  unsigned int D.28514;
  gchar * D.28515;
  struct GSList * D.28516;
  struct GSList * D.28517;
  gchar * D.28520;
  struct GSList * D.28521;
  int D.28522;
  struct ILStackDesc * D.28525;
  struct MonoClass * D.28526;
  struct MonoType * D.28527;
  struct MonoType * type;

  type = verifier_load_type (ctx, token, "sizeof");
  if (type == 0B) goto <D.28505>; else goto <D.28506>;
  <D.28505>:
  return;
  <D.28506>:
  D.28507 = BIT_FIELD_REF <*type, 8, 56>;
  D.28508 = D.28507 & 64;
  if (D.28508 != 0) goto <D.28509>; else goto <D.28510>;
  <D.28509>:
  D.28511 = type->type;
  if (D.28511 != 22) goto <D.28512>; else goto <D.28513>;
  <D.28512>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.28514 = ctx->ip_offset;
    D.28515 = monoeg_g_strdup_printf ("Invalid use of byref type at 0x%04x", D.28514);
    vinfo->info.message = D.28515;
    vinfo->exception_type = 3;
    D.28516 = ctx->list;
    D.28517 = monoeg_g_slist_prepend (D.28516, vinfo);
    ctx->list = D.28517;
  }
  ctx->valid = 0;
  return;
  <D.28513>:
  <D.28510>:
  D.28511 = type->type;
  if (D.28511 == 1) goto <D.28518>; else goto <D.28519>;
  <D.28518>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.28514 = ctx->ip_offset;
    D.28520 = monoeg_g_strdup_printf ("Invalid use of void type at 0x%04x", D.28514);
    vinfo->info.message = D.28520;
    vinfo->exception_type = 3;
    D.28516 = ctx->list;
    D.28521 = monoeg_g_slist_prepend (D.28516, vinfo);
    ctx->list = D.28521;
  }
  ctx->valid = 0;
  return;
  <D.28519>:
  D.28522 = check_overflow (ctx);
  if (D.28522 != 0) goto <D.28523>; else goto <D.28524>;
  <D.28523>:
  D.28525 = stack_push (ctx);
  D.28526 = mono_defaults.uint32_class;
  D.28527 = &D.28526->byval_arg;
  set_stack_value (ctx, D.28525, D.28527, 0);
  <D.28524>:
}


do_refanytype (struct VerifyContext * ctx)
{
  int D.28529;
  int D.28534;
  struct MonoType * D.28536;
  unsigned char D.28537;
  const char * D.28538;
  unsigned int D.28539;
  gchar * D.28540;
  struct GSList * D.28541;
  struct GSList * D.28542;
  struct ILStackDesc * D.28543;
  struct MonoClass * D.28544;
  struct MonoType * D.28545;
  struct ILStackDesc * top;

  D.28529 = check_underflow (ctx, 1);
  if (D.28529 == 0) goto <D.28530>; else goto <D.28531>;
  <D.28530>:
  return;
  <D.28531>:
  top = stack_pop (ctx);
  D.28534 = top->stype;
  if (D.28534 != 5) goto <D.28532>; else goto <D.28535>;
  <D.28535>:
  D.28536 = top->type;
  D.28537 = D.28536->type;
  if (D.28537 != 22) goto <D.28532>; else goto <D.28533>;
  <D.28532>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.28538 = stack_slot_get_name (top);
    D.28539 = ctx->ip_offset;
    D.28540 = monoeg_g_strdup_printf ("Expected a typedref as argument for refanytype, but found %s at 0x%04x", D.28538, D.28539);
    vinfo->info.message = D.28540;
    vinfo->exception_type = 3;
    D.28541 = ctx->list;
    D.28542 = monoeg_g_slist_prepend (D.28541, vinfo);
    ctx->list = D.28542;
  }
  ctx->valid = 0;
  <D.28533>:
  D.28543 = stack_push (ctx);
  D.28544 = mono_defaults.typehandle_class;
  D.28545 = &D.28544->byval_arg;
  set_stack_value (ctx, D.28543, D.28545, 0);
}


mono_method_is_constructor (struct MonoMethod * method)
{
  gboolean D.28547;
  int iftmp.129;
  short unsigned int D.28551;
  unsigned int D.28552;
  unsigned int D.28553;
  int D.20117;
  int iftmp.130;
  int D.20113;
  const char[6] * D.28558;
  unsigned char D.28559;
  int D.28560;
  unsigned char D.28561;
  int D.28562;
  _Bool D.28563;
  _Bool D.28564;
  _Bool D.28565;
  const unsigned char * D.28568;
  unsigned char D.28569;
  int D.28570;
  const unsigned char * D.28571;
  unsigned char D.28572;
  int D.28573;
  _Bool D.28574;
  _Bool D.28575;
  const unsigned char * D.28578;
  unsigned char D.28579;
  int D.28580;
  const unsigned char * D.28581;
  unsigned char D.28582;
  int D.28583;
  _Bool D.28584;
  _Bool D.28585;
  const unsigned char * D.28588;
  unsigned char D.28589;
  int D.28590;
  const unsigned char * D.28591;
  unsigned char D.28592;
  int D.28593;
  const char * D.28595;

  D.28551 = method->flags;
  D.28552 = (unsigned int) D.28551;
  D.28553 = D.28552 & 6160;
  if (D.28553 == 6144) goto <D.28554>; else goto <D.28549>;
  <D.28554>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.28558 = ".ctor";
      D.28559 = MEM[(const unsigned char *)D.28558];
      D.28560 = (int) D.28559;
      D.28561 = *__s2;
      D.28562 = (int) D.28561;
      __result = D.28560 - D.28562;
      {
        D.28563 = __s1_len != 0;
        D.28564 = __result == 0;
        D.28565 = D.28563 & D.28564;
        if (D.28565 != 0) goto <D.28566>; else goto <D.28567>;
        <D.28566>:
        D.28568 = &MEM[(void *)".ctor" + 1B];
        D.28569 = *D.28568;
        D.28570 = (int) D.28569;
        D.28571 = __s2 + 1;
        D.28572 = *D.28571;
        D.28573 = (int) D.28572;
        __result = D.28570 - D.28573;
        D.28574 = __s1_len > 1;
        D.28564 = __result == 0;
        D.28575 = D.28574 & D.28564;
        if (D.28575 != 0) goto <D.28576>; else goto <D.28577>;
        <D.28576>:
        D.28578 = &MEM[(void *)".ctor" + 2B];
        D.28579 = *D.28578;
        D.28580 = (int) D.28579;
        D.28581 = __s2 + 2;
        D.28582 = *D.28581;
        D.28583 = (int) D.28582;
        __result = D.28580 - D.28583;
        D.28584 = __s1_len > 2;
        D.28564 = __result == 0;
        D.28585 = D.28584 & D.28564;
        if (D.28585 != 0) goto <D.28586>; else goto <D.28587>;
        <D.28586>:
        D.28588 = &MEM[(void *)".ctor" + 3B];
        D.28589 = *D.28588;
        D.28590 = (int) D.28589;
        D.28591 = __s2 + 3;
        D.28592 = *D.28591;
        D.28593 = (int) D.28592;
        __result = D.28590 - D.28593;
        <D.28587>:
        <D.28577>:
        <D.28567>:
      }
      D.20113 = __result;
    }
    iftmp.130 = D.20113;
    goto <D.28594>;
    <D.28557>:
    D.28595 = method->name;
    iftmp.130 = __builtin_strcmp (".ctor", D.28595);
    <D.28594>:
    D.20117 = iftmp.130;
  }
  if (D.20117 == 0) goto <D.28596>; else goto <D.28549>;
  <D.28596>:
  iftmp.129 = 1;
  goto <D.28550>;
  <D.28549>:
  iftmp.129 = 0;
  <D.28550>:
  D.28547 = iftmp.129;
  return D.28547;
}


mono_verify_corlib ()
{
  char * D.28598;

  D.28598 = 0B;
  return D.28598;
}


mono_verifier_is_enabled_for_method (struct MonoMethod * method)
{
  gboolean D.28600;
  int iftmp.131;
  struct MonoClass * D.28604;
  int D.28605;
  unsigned char D.28607;
  unsigned char D.28608;
  _Bool D.28609;
  _Bool D.28610;
  _Bool D.28611;

  D.28604 = method->klass;
  D.28605 = mono_verifier_is_enabled_for_class (D.28604);
  if (D.28605 != 0) goto <D.28606>; else goto <D.28602>;
  <D.28606>:
  D.28607 = BIT_FIELD_REF <*method, 8, 160>;
  D.28608 = D.28607 & 124;
  D.28609 = D.28608 == 0;
  D.28610 = D.28608 == 68;
  D.28611 = D.28609 | D.28610;
  if (D.28611 != 0) goto <D.28612>; else goto <D.28602>;
  <D.28612>:
  iftmp.131 = 1;
  goto <D.28603>;
  <D.28602>:
  iftmp.131 = 0;
  <D.28603>:
  D.28600 = iftmp.131;
  return D.28600;
}


mono_verifier_is_enabled_for_class (struct MonoClass * klass)
{
  gboolean D.28614;
  int iftmp.132;
  int verify_all.133;
  <unnamed type> verifier_mode.134;
  struct MonoImage * D.28624;
  struct MonoAssembly * D.28625;
  unsigned char D.28627;
  struct MonoImage * D.28628;

  verify_all.133 = verify_all;
  if (verify_all.133 != 0) goto <D.28616>; else goto <D.28621>;
  <D.28621>:
  verifier_mode.134 = verifier_mode;
  if (verifier_mode.134 != 0) goto <D.28623>; else goto <D.28617>;
  <D.28623>:
  D.28624 = klass->image;
  D.28625 = D.28624->assembly;
  if (D.28625 == 0B) goto <D.28618>; else goto <D.28626>;
  <D.28626>:
  D.28624 = klass->image;
  D.28625 = D.28624->assembly;
  D.28627 = D.28625->in_gac;
  if (D.28627 == 0) goto <D.28618>; else goto <D.28617>;
  <D.28618>:
  D.28624 = klass->image;
  D.28628 = mono_defaults.corlib;
  if (D.28624 != D.28628) goto <D.28616>; else goto <D.28617>;
  <D.28616>:
  iftmp.132 = 1;
  goto <D.28619>;
  <D.28617>:
  iftmp.132 = 0;
  <D.28619>:
  D.28614 = iftmp.132;
  return D.28614;
}


mono_verifier_is_enabled_for_image (struct MonoImage * image)
{
  gboolean D.28630;
  int iftmp.135;
  int verify_all.136;
  <unnamed type> verifier_mode.137;

  verify_all.136 = verify_all;
  if (verify_all.136 != 0) goto <D.28632>; else goto <D.28636>;
  <D.28636>:
  verifier_mode.137 = verifier_mode;
  if (verifier_mode.137 != 0) goto <D.28632>; else goto <D.28633>;
  <D.28632>:
  iftmp.135 = 1;
  goto <D.28634>;
  <D.28633>:
  iftmp.135 = 0;
  <D.28634>:
  D.28630 = iftmp.135;
  return D.28630;
}


mono_verifier_is_method_full_trust (struct MonoMethod * method)
{
  gboolean D.28639;
  int iftmp.138;
  struct MonoClass * D.28643;
  int D.28644;
  unsigned char D.28646;
  unsigned char D.28647;

  D.28643 = method->klass;
  D.28644 = mono_verifier_is_class_full_trust (D.28643);
  if (D.28644 != 0) goto <D.28645>; else goto <D.28641>;
  <D.28645>:
  D.28646 = BIT_FIELD_REF <*method, 8, 168>;
  D.28647 = D.28646 & 2;
  if (D.28647 == 0) goto <D.28648>; else goto <D.28641>;
  <D.28648>:
  iftmp.138 = 1;
  goto <D.28642>;
  <D.28641>:
  iftmp.138 = 0;
  <D.28642>:
  D.28639 = iftmp.138;
  return D.28639;
}


mono_verifier_is_class_full_trust (struct MonoClass * klass)
{
  int iftmp.139;
  <unnamed type> D.28651;
  int iftmp.140;
  struct MonoImage * D.28657;
  struct MonoAssembly * D.28658;
  unsigned char D.28660;
  int verify_all.141;
  <unnamed type> verifier_mode.142;
  gboolean D.28669;
  int iftmp.143;
  struct MonoImage * D.28675;
  int iftmp.144;
  gboolean trusted_location;

  D.28651 = mono_security_get_mode ();
  if (D.28651 != 1) goto <D.28652>; else goto <D.28653>;
  <D.28652>:
  D.28657 = klass->image;
  D.28658 = D.28657->assembly;
  if (D.28658 != 0B) goto <D.28659>; else goto <D.28655>;
  <D.28659>:
  D.28657 = klass->image;
  D.28658 = D.28657->assembly;
  D.28660 = D.28658->in_gac;
  if (D.28660 != 0) goto <D.28661>; else goto <D.28655>;
  <D.28661>:
  iftmp.140 = 1;
  goto <D.28656>;
  <D.28655>:
  iftmp.140 = 0;
  <D.28656>:
  iftmp.139 = iftmp.140;
  goto <D.28662>;
  <D.28653>:
  D.28657 = klass->image;
  iftmp.139 = mono_security_core_clr_is_platform_image (D.28657);
  <D.28662>:
  trusted_location = iftmp.139;
  verify_all.141 = verify_all;
  if (verify_all.141 != 0) goto <D.28664>; else goto <D.28665>;
  <D.28664>:
  verifier_mode.142 = verifier_mode;
  if (verifier_mode.142 == 0) goto <D.28667>; else goto <D.28668>;
  <D.28667>:
  if (trusted_location != 0) goto <D.28671>; else goto <D.28674>;
  <D.28674>:
  D.28657 = klass->image;
  D.28675 = mono_defaults.corlib;
  if (D.28657 == D.28675) goto <D.28671>; else goto <D.28672>;
  <D.28671>:
  iftmp.143 = 1;
  goto <D.28673>;
  <D.28672>:
  iftmp.143 = 0;
  <D.28673>:
  D.28669 = iftmp.143;
  return D.28669;
  <D.28668>:
  <D.28665>:
  verifier_mode.142 = verifier_mode;
  if (verifier_mode.142 <= 1) goto <D.28677>; else goto <D.28680>;
  <D.28680>:
  if (trusted_location != 0) goto <D.28677>; else goto <D.28681>;
  <D.28681>:
  D.28657 = klass->image;
  D.28675 = mono_defaults.corlib;
  if (D.28657 == D.28675) goto <D.28677>; else goto <D.28678>;
  <D.28677>:
  iftmp.144 = 1;
  goto <D.28679>;
  <D.28678>:
  iftmp.144 = 0;
  <D.28679>:
  D.28669 = iftmp.144;
  return D.28669;
}


mono_method_verify_with_current_settings (struct MonoMethod * method, gboolean skip_visibility, gboolean is_fulltrust)
{
  struct GSList * D.28683;
  int iftmp.145;
  <unnamed type> verifier_mode.146;
  int iftmp.147;
  int D.28693;
  int D.28695;
  int iftmp.148;
  int D.28700;

  verifier_mode.146 = verifier_mode;
  if (verifier_mode.146 != 3) goto <D.28686>; else goto <D.28687>;
  <D.28686>:
  iftmp.145 = 32;
  goto <D.28688>;
  <D.28687>:
  iftmp.145 = 0;
  <D.28688>:
  if (is_fulltrust == 0) goto <D.28692>; else goto <D.28690>;
  <D.28692>:
  D.28693 = mono_verifier_is_method_full_trust (method);
  if (D.28693 == 0) goto <D.28694>; else goto <D.28690>;
  <D.28694>:
  iftmp.147 = 16;
  goto <D.28691>;
  <D.28690>:
  iftmp.147 = 0;
  <D.28691>:
  D.28695 = iftmp.145 | iftmp.147;
  if (skip_visibility != 0) goto <D.28697>; else goto <D.28698>;
  <D.28697>:
  iftmp.148 = 64;
  goto <D.28699>;
  <D.28698>:
  iftmp.148 = 0;
  <D.28699>:
  D.28700 = D.28695 | iftmp.148;
  D.28683 = mono_method_verify (method, D.28700);
  return D.28683;
}


mono_verifier_verify_class (struct MonoClass * class)
{
  struct MonoClass * D.28702;
  struct MonoClass * D.28705;
  unsigned int D.28708;
  unsigned int D.28709;
  unsigned char D.28712;
  struct MonoImage * D.28717;
  unsigned char D.28718;
  unsigned char D.28719;
  unsigned int D.28722;
  gboolean D.28725;
  unsigned int D.28730;
  unsigned int D.28731;
  unsigned char D.28733;
  struct MonoGenericClass * D.28735;
  struct MonoGenericContainer * D.28738;
  struct MonoGenericClass * D.28741;
  struct MonoGenericContainer * D.28746;
  struct MonoType * D.28749;
  int D.28750;
  unsigned int D.28755;
  int D.28760;
  int D.28763;
  int D.28768;
  int D.28773;
  unsigned char D.28776;
  unsigned char D.28777;
  int D.28780;
  int D.28783;

  D.28702 = class->parent;
  if (D.28702 == 0B) goto <D.28703>; else goto <D.28704>;
  <D.28703>:
  D.28705 = mono_defaults.object_class;
  if (D.28705 != class) goto <D.28706>; else goto <D.28707>;
  <D.28706>:
  D.28708 = class->flags;
  D.28709 = D.28708 & 32;
  if (D.28709 == 0) goto <D.28710>; else goto <D.28711>;
  <D.28710>:
  D.28712 = class->byval_arg.type;
  if (D.28712 != 19) goto <D.28713>; else goto <D.28714>;
  <D.28713>:
  D.28712 = class->byval_arg.type;
  if (D.28712 != 30) goto <D.28715>; else goto <D.28716>;
  <D.28715>:
  D.28717 = class->image;
  D.28718 = BIT_FIELD_REF <*D.28717, 8, 128>;
  D.28719 = D.28718 & 8;
  if (D.28719 == 0) goto <D.28720>; else goto <D.28721>;
  <D.28720>:
  D.28722 = class->type_token;
  if (D.28722 != 33554433) goto <D.28723>; else goto <D.28724>;
  <D.28723>:
  D.28725 = 0;
  return D.28725;
  <D.28724>:
  <D.28721>:
  <D.28716>:
  <D.28714>:
  <D.28711>:
  <D.28707>:
  <D.28704>:
  D.28702 = class->parent;
  if (D.28702 != 0B) goto <D.28726>; else goto <D.28727>;
  <D.28726>:
  D.28702 = class->parent;
  D.28730 = D.28702->flags;
  D.28731 = D.28730 & 32;
  if (D.28731 != 0) goto <D.28728>; else goto <D.28732>;
  <D.28732>:
  D.28702 = class->parent;
  D.28733 = D.28702->byval_arg.type;
  if (D.28733 == 19) goto <D.28728>; else goto <D.28734>;
  <D.28734>:
  D.28702 = class->parent;
  D.28733 = D.28702->byval_arg.type;
  if (D.28733 == 30) goto <D.28728>; else goto <D.28729>;
  <D.28728>:
  D.28725 = 0;
  return D.28725;
  <D.28729>:
  D.28735 = class->generic_class;
  if (D.28735 == 0B) goto <D.28736>; else goto <D.28737>;
  <D.28736>:
  D.28702 = class->parent;
  D.28738 = D.28702->generic_container;
  if (D.28738 != 0B) goto <D.28739>; else goto <D.28740>;
  <D.28739>:
  D.28725 = 0;
  return D.28725;
  <D.28740>:
  <D.28737>:
  D.28702 = class->parent;
  D.28741 = D.28702->generic_class;
  if (D.28741 != 0B) goto <D.28742>; else goto <D.28743>;
  <D.28742>:
  D.28735 = class->generic_class;
  if (D.28735 == 0B) goto <D.28744>; else goto <D.28745>;
  <D.28744>:
  {
    struct MonoGenericContext * context;

    context = mono_class_get_context (class);
    D.28746 = class->generic_container;
    if (D.28746 != 0B) goto <D.28747>; else goto <D.28748>;
    <D.28747>:
    D.28746 = class->generic_container;
    context = &D.28746->context;
    <D.28748>:
    D.28702 = class->parent;
    D.28749 = &D.28702->byval_arg;
    D.28750 = mono_type_is_valid_type_in_context (D.28749, context);
    if (D.28750 == 0) goto <D.28751>; else goto <D.28752>;
    <D.28751>:
    D.28725 = 0;
    return D.28725;
    <D.28752>:
  }
  <D.28745>:
  <D.28743>:
  <D.28727>:
  D.28746 = class->generic_container;
  if (D.28746 != 0B) goto <D.28753>; else goto <D.28754>;
  <D.28753>:
  D.28708 = class->flags;
  D.28755 = D.28708 & 24;
  if (D.28755 == 16) goto <D.28756>; else goto <D.28757>;
  <D.28756>:
  D.28725 = 0;
  return D.28725;
  <D.28757>:
  <D.28754>:
  D.28746 = class->generic_container;
  if (D.28746 != 0B) goto <D.28758>; else goto <D.28759>;
  <D.28758>:
  D.28760 = verify_generic_parameters (class);
  if (D.28760 == 0) goto <D.28761>; else goto <D.28762>;
  <D.28761>:
  D.28725 = 0;
  return D.28725;
  <D.28762>:
  <D.28759>:
  D.28763 = verify_class_for_overlapping_reference_fields (class);
  if (D.28763 == 0) goto <D.28764>; else goto <D.28765>;
  <D.28764>:
  D.28725 = 0;
  return D.28725;
  <D.28765>:
  D.28735 = class->generic_class;
  if (D.28735 != 0B) goto <D.28766>; else goto <D.28767>;
  <D.28766>:
  D.28768 = mono_class_is_valid_generic_instantiation (0B, class);
  if (D.28768 == 0) goto <D.28769>; else goto <D.28770>;
  <D.28769>:
  D.28725 = 0;
  return D.28725;
  <D.28770>:
  <D.28767>:
  D.28735 = class->generic_class;
  if (D.28735 == 0B) goto <D.28771>; else goto <D.28772>;
  <D.28771>:
  D.28773 = verify_class_fields (class);
  if (D.28773 == 0) goto <D.28774>; else goto <D.28775>;
  <D.28774>:
  D.28725 = 0;
  return D.28725;
  <D.28775>:
  <D.28772>:
  D.28776 = BIT_FIELD_REF <*class, 8, 160>;
  D.28777 = D.28776 & 8;
  if (D.28777 != 0) goto <D.28778>; else goto <D.28779>;
  <D.28778>:
  D.28780 = verify_valuetype_layout (class);
  if (D.28780 == 0) goto <D.28781>; else goto <D.28782>;
  <D.28781>:
  D.28725 = 0;
  return D.28725;
  <D.28782>:
  <D.28779>:
  D.28783 = verify_interfaces (class);
  if (D.28783 == 0) goto <D.28784>; else goto <D.28785>;
  <D.28784>:
  D.28725 = 0;
  return D.28725;
  <D.28785>:
  D.28725 = 1;
  return D.28725;
}


verify_generic_parameters (struct MonoClass * class)
{
  <unnamed-signed:31> D.28787;
  unsigned int D.28788;
  struct MonoGenericParamFull * D.28789;
  unsigned int i.149;
  unsigned int D.28791;
  struct MonoGenericParamFull * D.28792;
  struct MonoClass * * D.28793;
  unsigned int D.28796;
  unsigned int D.28797;
  int D.28798;
  unsigned int D.28799;
  unsigned int D.28800;
  int D.28801;
  struct MonoGenericContext * D.28803;
  int D.28804;
  int D.28806;
  int D.28809;
  struct MonoGenericClass * D.28811;
  int D.28814;
  struct MonoClass * D.28816;
  int D.28817;
  gboolean D.28818;
  int i;
  struct MonoGenericContainer * gc;
  struct MonoBitSet * used_args;
  void fail = <<< error >>>;

  gc = class->generic_container;
  D.28787 = gc->type_argc;
  D.28788 = (unsigned int) D.28787;
  used_args = mono_bitset_new (D.28788, 0);
  i = 0;
  goto <D.22157>;
  <D.22156>:
  {
    struct MonoGenericParamInfo * param_info;
    struct MonoClass * * constraints;

    D.28789 = gc->type_params;
    i.149 = (unsigned int) i;
    D.28791 = i.149 * 32;
    D.28792 = D.28789 + D.28791;
    param_info = &D.28792->info;
    D.28793 = param_info->constraints;
    if (D.28793 == 0B) goto <D.28794>; else goto <D.28795>;
    <D.28794>:
    // predicted unlikely by continue predictor.
    goto <D.22149>;
    <D.28795>:
    mono_bitset_clear_all (used_args);
    i.149 = (unsigned int) i;
    D.28796 = i.149 / 32;
    D.28797 = used_args->data[D.28796];
    D.28798 = i & 31;
    D.28799 = 1 << D.28798;
    D.28800 = D.28797 | D.28799;
    used_args->data[D.28796] = D.28800;
    constraints = param_info->constraints;
    goto <D.22154>;
    <D.22153>:
    {
      struct MonoClass * ctr;
      struct MonoType * constraint_type;

      ctr = *constraints;
      constraint_type = &ctr->byval_arg;
      D.28801 = mono_class_can_access_class (class, ctr);
      if (D.28801 == 0) goto fail; else goto <D.28802>;
      <D.28802>:
      D.28803 = &gc->context;
      D.28804 = mono_type_is_valid_type_in_context (constraint_type, D.28803);
      if (D.28804 == 0) goto fail; else goto <D.28805>;
      <D.28805>:
      D.28806 = mono_type_is_generic_argument (constraint_type);
      if (D.28806 != 0) goto <D.28807>; else goto <D.28808>;
      <D.28807>:
      D.28809 = recursive_mark_constraint_args (used_args, gc, constraint_type);
      if (D.28809 == 0) goto fail; else goto <D.28810>;
      <D.28810>:
      <D.28808>:
      D.28811 = ctr->generic_class;
      if (D.28811 != 0B) goto <D.28812>; else goto <D.28813>;
      <D.28812>:
      D.28814 = mono_class_is_valid_generic_instantiation (0B, ctr);
      if (D.28814 == 0) goto fail; else goto <D.28815>;
      <D.28815>:
      <D.28813>:
    }
    constraints = constraints + 4;
    <D.22154>:
    D.28816 = *constraints;
    if (D.28816 != 0B) goto <D.22153>; else goto <D.22155>;
    <D.22155>:
  }
  <D.22149>:
  i = i + 1;
  <D.22157>:
  D.28787 = gc->type_argc;
  D.28817 = (int) D.28787;
  if (D.28817 > i) goto <D.22156>; else goto <D.22158>;
  <D.22158>:
  mono_bitset_free (used_args);
  D.28818 = 1;
  return D.28818;
  fail:
  mono_bitset_free (used_args);
  D.28818 = 0;
  return D.28818;
}


recursive_mark_constraint_args (struct MonoBitSet * used_args, struct MonoGenericContainer * gc, struct MonoType * type)
{
  int D.28820;
  _Bool D.28821;
  long int D.28822;
  long int D.28823;
  struct MonoGenericParam * D.28826;
  short unsigned int D.28827;
  unsigned int idx.150;
  unsigned int D.28829;
  unsigned int D.28830;
  int D.28831;
  unsigned int D.28832;
  unsigned int D.28833;
  gboolean D.28836;
  unsigned int D.28837;
  unsigned int D.28838;
  unsigned int D.28839;
  struct MonoGenericParamFull * D.28840;
  unsigned int D.28841;
  struct MonoGenericParamFull * D.28842;
  struct MonoClass * * D.28843;
  int D.28846;
  int D.28849;
  struct MonoClass * D.28852;
  int idx;
  struct MonoClass * * constraints;
  struct MonoGenericParamInfo * param_info;

  D.28820 = mono_type_is_generic_argument (type);
  D.28821 = D.28820 == 0;
  D.28822 = (long int) D.28821;
  D.28823 = __builtin_expect (D.28822, 0);
  if (D.28823 != 0) goto <D.28824>; else goto <D.28825>;
  <D.28824>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "verify.c", 6206, "mono_type_is_generic_argument (type)");
  <D.28825>:
  D.28826 = type->data.generic_param;
  D.28827 = D.28826->num;
  idx = (int) D.28827;
  idx.150 = (unsigned int) idx;
  D.28829 = idx.150 / 32;
  D.28830 = used_args->data[D.28829];
  D.28831 = idx & 31;
  D.28832 = 1 << D.28831;
  D.28833 = D.28830 & D.28832;
  if (D.28833 != 0) goto <D.28834>; else goto <D.28835>;
  <D.28834>:
  D.28836 = 0;
  return D.28836;
  <D.28835>:
  idx.150 = (unsigned int) idx;
  D.28837 = idx.150 / 32;
  D.28838 = used_args->data[D.28837];
  D.28831 = idx & 31;
  D.28832 = 1 << D.28831;
  D.28839 = D.28838 | D.28832;
  used_args->data[D.28837] = D.28839;
  D.28840 = gc->type_params;
  idx.150 = (unsigned int) idx;
  D.28841 = idx.150 * 32;
  D.28842 = D.28840 + D.28841;
  param_info = &D.28842->info;
  D.28843 = param_info->constraints;
  if (D.28843 == 0B) goto <D.28844>; else goto <D.28845>;
  <D.28844>:
  D.28836 = 1;
  return D.28836;
  <D.28845>:
  constraints = param_info->constraints;
  goto <D.22139>;
  <D.22138>:
  {
    struct MonoClass * ctr;
    struct MonoType * constraint_type;

    ctr = *constraints;
    constraint_type = &ctr->byval_arg;
    D.28846 = mono_type_is_generic_argument (constraint_type);
    if (D.28846 != 0) goto <D.28847>; else goto <D.28848>;
    <D.28847>:
    D.28849 = recursive_mark_constraint_args (used_args, gc, constraint_type);
    if (D.28849 == 0) goto <D.28850>; else goto <D.28851>;
    <D.28850>:
    D.28836 = 0;
    return D.28836;
    <D.28851>:
    <D.28848>:
  }
  constraints = constraints + 4;
  <D.22139>:
  D.28852 = *constraints;
  if (D.28852 != 0B) goto <D.22138>; else goto <D.22140>;
  <D.22140>:
  D.28836 = 1;
  return D.28836;
}


verify_class_for_overlapping_reference_fields (struct MonoClass * class)
{
  unsigned int D.28854;
  unsigned int D.28855;
  gboolean D.28858;
  struct MonoType * D.28859;
  int D.28860;
  _Bool D.28861;
  short unsigned int D.28865;
  int D.28866;
  int D.28867;
  int D.22057;
  int iftmp.151;
  int D.22056;
  const char[9] * D.28872;
  unsigned char D.28873;
  int D.28874;
  unsigned char D.28875;
  int D.28876;
  _Bool D.28877;
  _Bool D.28878;
  _Bool D.28879;
  const unsigned char * D.28882;
  unsigned char D.28883;
  int D.28884;
  const unsigned char * D.28885;
  unsigned char D.28886;
  int D.28887;
  _Bool D.28888;
  _Bool D.28889;
  const unsigned char * D.28892;
  unsigned char D.28893;
  int D.28894;
  const unsigned char * D.28895;
  unsigned char D.28896;
  int D.28897;
  _Bool D.28898;
  _Bool D.28899;
  const unsigned char * D.28902;
  unsigned char D.28903;
  int D.28904;
  const unsigned char * D.28905;
  unsigned char D.28906;
  int D.28907;
  const char * D.28909;
  int D.28910;
  struct MonoClassField * D.28911;
  unsigned int j.152;
  unsigned int D.28913;
  struct MonoType * D.28918;
  short unsigned int D.28919;
  int D.28920;
  int D.28921;
  int D.22069;
  int iftmp.153;
  int D.22068;
  unsigned char D.28926;
  int D.28927;
  _Bool D.28928;
  _Bool D.28929;
  _Bool D.28930;
  const unsigned char * D.28933;
  unsigned char D.28934;
  int D.28935;
  _Bool D.28936;
  _Bool D.28937;
  const unsigned char * D.28940;
  unsigned char D.28941;
  int D.28942;
  _Bool D.28943;
  _Bool D.28944;
  const unsigned char * D.28947;
  unsigned char D.28948;
  int D.28949;
  const char * D.28951;
  int D.28953;
  int D.28954;
  int D.28957;
  int D.28960;
  int D.28961;
  unsigned int j.154;
  unsigned int D.28972;
  int i;
  int j;
  void * iter;
  struct MonoClassField * field;
  gboolean is_fulltrust;

  try
    {
      i = 0;
      iter = 0B;
      is_fulltrust = mono_verifier_is_class_full_trust (class);
      D.28854 = class->flags;
      D.28855 = D.28854 & 24;
      if (D.28855 != 16) goto <D.28856>; else goto <D.28857>;
      <D.28856>:
      D.28858 = 1;
      return D.28858;
      <D.28857>:
      goto <D.22058>;
      <D.22074>:
      {
        int fieldEnd;
        gboolean is_valuetype;

        fieldEnd = get_field_end (field);
        D.28859 = field->type;
        D.28860 = mono_type_is_reference (D.28859);
        D.28861 = D.28860 == 0;
        is_valuetype = (gboolean) D.28861;
        i = i + 1;
        D.28859 = field->type;
        D.28865 = D.28859->attrs;
        D.28866 = (int) D.28865;
        D.28867 = D.28866 & 1536;
        if (D.28867 != 0) goto <D.28868>; else goto <D.28862>;
        <D.28868>:
        {
          size_t __s1_len;
          size_t __s2_len;

          __s2_len = 8;
          if (__s2_len <= 3) goto <D.28870>; else goto <D.28871>;
          <D.28870>:
          {
            const unsigned char * __s2;
            int __result;

            __s2 = mono_field_get_name (field);
            D.28872 = "_Deleted";
            D.28873 = MEM[(const unsigned char *)D.28872];
            D.28874 = (int) D.28873;
            D.28875 = *__s2;
            D.28876 = (int) D.28875;
            __result = D.28874 - D.28876;
            {
              D.28877 = __s2_len != 0;
              D.28878 = __result == 0;
              D.28879 = D.28877 & D.28878;
              if (D.28879 != 0) goto <D.28880>; else goto <D.28881>;
              <D.28880>:
              D.28882 = &MEM[(void *)"_Deleted" + 1B];
              D.28883 = *D.28882;
              D.28884 = (int) D.28883;
              D.28885 = __s2 + 1;
              D.28886 = *D.28885;
              D.28887 = (int) D.28886;
              __result = D.28884 - D.28887;
              D.28888 = __s2_len > 1;
              D.28878 = __result == 0;
              D.28889 = D.28888 & D.28878;
              if (D.28889 != 0) goto <D.28890>; else goto <D.28891>;
              <D.28890>:
              D.28892 = &MEM[(void *)"_Deleted" + 2B];
              D.28893 = *D.28892;
              D.28894 = (int) D.28893;
              D.28895 = __s2 + 2;
              D.28896 = *D.28895;
              D.28897 = (int) D.28896;
              __result = D.28894 - D.28897;
              D.28898 = __s2_len > 2;
              D.28878 = __result == 0;
              D.28899 = D.28898 & D.28878;
              if (D.28899 != 0) goto <D.28900>; else goto <D.28901>;
              <D.28900>:
              D.28902 = &MEM[(void *)"_Deleted" + 3B];
              D.28903 = *D.28902;
              D.28904 = (int) D.28903;
              D.28905 = __s2 + 3;
              D.28906 = *D.28905;
              D.28907 = (int) D.28906;
              __result = D.28904 - D.28907;
              <D.28901>:
              <D.28891>:
              <D.28881>:
            }
            D.22056 = __result;
          }
          iftmp.151 = -D.22056;
          goto <D.28908>;
          <D.28871>:
          D.28909 = mono_field_get_name (field);
          iftmp.151 = __builtin_strcmp (D.28909, "_Deleted");
          <D.28908>:
          D.22057 = iftmp.151;
        }
        if (D.22057 == 0) goto <D.28863>; else goto <D.28862>;
        <D.28862>:
        D.28859 = field->type;
        D.28865 = D.28859->attrs;
        D.28866 = (int) D.28865;
        D.28910 = D.28866 & 16;
        if (D.28910 != 0) goto <D.28863>; else goto <D.28864>;
        <D.28863>:
        // predicted unlikely by continue predictor.
        goto <D.22058>;
        <D.28864>:
        j = i;
        goto <D.22072>;
        <D.22071>:
        {
          struct MonoClassField * other;
          int otherEnd;

          D.28911 = class->fields;
          j.152 = (unsigned int) j;
          D.28913 = j.152 * 16;
          other = D.28911 + D.28913;
          otherEnd = get_field_end (other);
          D.28918 = other->type;
          D.28919 = D.28918->attrs;
          D.28920 = (int) D.28919;
          D.28921 = D.28920 & 1536;
          if (D.28921 != 0) goto <D.28922>; else goto <D.28914>;
          <D.28922>:
          {
            size_t __s1_len;
            size_t __s2_len;

            __s2_len = 8;
            if (__s2_len <= 3) goto <D.28924>; else goto <D.28925>;
            <D.28924>:
            {
              const unsigned char * __s2;
              int __result;

              __s2 = mono_field_get_name (other);
              D.28872 = "_Deleted";
              D.28873 = MEM[(const unsigned char *)D.28872];
              D.28874 = (int) D.28873;
              D.28926 = *__s2;
              D.28927 = (int) D.28926;
              __result = D.28874 - D.28927;
              {
                D.28928 = __s2_len != 0;
                D.28929 = __result == 0;
                D.28930 = D.28928 & D.28929;
                if (D.28930 != 0) goto <D.28931>; else goto <D.28932>;
                <D.28931>:
                D.28882 = &MEM[(void *)"_Deleted" + 1B];
                D.28883 = *D.28882;
                D.28884 = (int) D.28883;
                D.28933 = __s2 + 1;
                D.28934 = *D.28933;
                D.28935 = (int) D.28934;
                __result = D.28884 - D.28935;
                D.28936 = __s2_len > 1;
                D.28929 = __result == 0;
                D.28937 = D.28936 & D.28929;
                if (D.28937 != 0) goto <D.28938>; else goto <D.28939>;
                <D.28938>:
                D.28892 = &MEM[(void *)"_Deleted" + 2B];
                D.28893 = *D.28892;
                D.28894 = (int) D.28893;
                D.28940 = __s2 + 2;
                D.28941 = *D.28940;
                D.28942 = (int) D.28941;
                __result = D.28894 - D.28942;
                D.28943 = __s2_len > 2;
                D.28929 = __result == 0;
                D.28944 = D.28943 & D.28929;
                if (D.28944 != 0) goto <D.28945>; else goto <D.28946>;
                <D.28945>:
                D.28902 = &MEM[(void *)"_Deleted" + 3B];
                D.28903 = *D.28902;
                D.28904 = (int) D.28903;
                D.28947 = __s2 + 3;
                D.28948 = *D.28947;
                D.28949 = (int) D.28948;
                __result = D.28904 - D.28949;
                <D.28946>:
                <D.28939>:
                <D.28932>:
              }
              D.22068 = __result;
            }
            iftmp.153 = -D.22068;
            goto <D.28950>;
            <D.28925>:
            D.28951 = mono_field_get_name (other);
            iftmp.153 = __builtin_strcmp (D.28951, "_Deleted");
            <D.28950>:
            D.22069 = iftmp.153;
          }
          if (D.22069 == 0) goto <D.28915>; else goto <D.28914>;
          <D.28914>:
          if (is_valuetype != 0) goto <D.28952>; else goto <D.28916>;
          <D.28952>:
          D.28918 = other->type;
          D.28953 = mono_type_is_reference (D.28918);
          if (D.28953 == 0) goto <D.28915>; else goto <D.28916>;
          <D.28916>:
          D.28918 = other->type;
          D.28919 = D.28918->attrs;
          D.28920 = (int) D.28919;
          D.28954 = D.28920 & 16;
          if (D.28954 != 0) goto <D.28915>; else goto <D.28917>;
          <D.28915>:
          // predicted unlikely by continue predictor.
          goto <D.22070>;
          <D.28917>:
          if (is_valuetype == 0) goto <D.28955>; else goto <D.28956>;
          <D.28955>:
          D.28918 = other->type;
          D.28957 = mono_type_is_reference (D.28918);
          if (D.28957 != 0) goto <D.28958>; else goto <D.28959>;
          <D.28958>:
          D.28960 = field->offset;
          D.28961 = other->offset;
          if (D.28960 == D.28961) goto <D.28962>; else goto <D.28963>;
          <D.28962>:
          if (is_fulltrust != 0) goto <D.28964>; else goto <D.28965>;
          <D.28964>:
          // predicted unlikely by continue predictor.
          goto <D.22070>;
          <D.28965>:
          <D.28963>:
          <D.28959>:
          <D.28956>:
          D.28960 = field->offset;
          if (D.28960 < otherEnd) goto <D.28969>; else goto <D.28966>;
          <D.28969>:
          if (otherEnd <= fieldEnd) goto <D.28967>; else goto <D.28966>;
          <D.28966>:
          D.28961 = other->offset;
          D.28960 = field->offset;
          if (D.28961 >= D.28960) goto <D.28970>; else goto <D.28968>;
          <D.28970>:
          D.28961 = other->offset;
          if (D.28961 < fieldEnd) goto <D.28967>; else goto <D.28968>;
          <D.28967>:
          D.28858 = 0;
          return D.28858;
          <D.28968>:
        }
        <D.22070>:
        j = j + 1;
        <D.22072>:
        j.154 = (unsigned int) j;
        D.28972 = class->field.count;
        if (j.154 < D.28972) goto <D.22071>; else goto <D.22073>;
        <D.22073>:
      }
      <D.22058>:
      field = mono_class_get_fields (class, &iter);
      if (field != 0B) goto <D.22074>; else goto <D.22075>;
      <D.22075>:
      D.28858 = 1;
      return D.28858;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


get_field_end (struct MonoClassField * field)
{
  struct MonoType * D.28975;
  int D.28978;
  int D.28979;
  int align;
  int size;

  try
    {
      D.28975 = field->type;
      size = mono_type_size (D.28975, &align);
      if (size == 0) goto <D.28976>; else goto <D.28977>;
      <D.28976>:
      size = 4;
      <D.28977>:
      D.28979 = field->offset;
      D.28978 = D.28979 + size;
      return D.28978;
    }
  finally
    {
      align = {CLOBBER};
    }
}


verify_class_fields (struct MonoClass * class)
{
  struct MonoGenericContainer * D.28982;
  struct MonoType * D.28985;
  int D.28986;
  gboolean D.28989;
  void * D.28990;
  void * iter;
  struct MonoClassField * field;
  struct MonoGenericContext * context;
  struct GHashTable * unique_fields;

  try
    {
      iter = 0B;
      context = mono_class_get_context (class);
      unique_fields = monoeg_g_hash_table_new_full (field_hash, field_equals, 0B, 0B);
      D.28982 = class->generic_container;
      if (D.28982 != 0B) goto <D.28983>; else goto <D.28984>;
      <D.28983>:
      D.28982 = class->generic_container;
      context = &D.28982->context;
      <D.28984>:
      goto <D.22103>;
      <D.22102>:
      D.28985 = field->type;
      D.28986 = mono_type_is_valid_type_in_context (D.28985, context);
      if (D.28986 == 0) goto <D.28987>; else goto <D.28988>;
      <D.28987>:
      monoeg_g_hash_table_destroy (unique_fields);
      D.28989 = 0;
      return D.28989;
      <D.28988>:
      D.28990 = monoeg_g_hash_table_lookup (unique_fields, field);
      if (D.28990 != 0B) goto <D.28991>; else goto <D.28992>;
      <D.28991>:
      monoeg_g_hash_table_destroy (unique_fields);
      D.28989 = 0;
      return D.28989;
      <D.28992>:
      monoeg_g_hash_table_insert_replace (unique_fields, field, field, 0);
      <D.22103>:
      field = mono_class_get_fields (class, &iter);
      if (field != 0B) goto <D.22102>; else goto <D.22104>;
      <D.22104>:
      monoeg_g_hash_table_destroy (unique_fields);
      D.28989 = 1;
      return D.28989;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


field_equals (const void * _a, const void * _b)
{
  gboolean D.28995;
  int iftmp.155;
  int D.22094;
  const char * D.28999;
  const char * D.29000;
  struct MonoType * D.29002;
  struct MonoType * D.29003;
  int D.29004;
  const struct MonoClassField * a;
  const struct MonoClassField * b;

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

    D.28999 = a->name;
    D.29000 = b->name;
    D.22094 = __builtin_strcmp (D.28999, D.29000);
  }
  if (D.22094 == 0) goto <D.29001>; else goto <D.28997>;
  <D.29001>:
  D.29002 = a->type;
  D.29003 = b->type;
  D.29004 = mono_metadata_type_equal (D.29002, D.29003);
  if (D.29004 != 0) goto <D.29005>; else goto <D.28997>;
  <D.29005>:
  iftmp.155 = 1;
  goto <D.28998>;
  <D.28997>:
  iftmp.155 = 0;
  <D.28998>:
  D.28995 = iftmp.155;
  return D.28995;
}


field_hash (const void * key)
{
  guint D.29007;
  const char * D.29008;
  unsigned int D.29009;
  struct MonoType * D.29010;
  unsigned int D.29011;
  const struct MonoClassField * field;

  field = key;
  D.29008 = field->name;
  D.29009 = monoeg_g_str_hash (D.29008);
  D.29010 = field->type;
  D.29011 = mono_metadata_type_hash (D.29010);
  D.29007 = D.29009 ^ D.29011;
  return D.29007;
}


verify_valuetype_layout (struct MonoClass * class)
{
  gboolean D.29013;
  gboolean res;

  res = verify_valuetype_layout_with_target (class, class);
  D.29013 = res;
  return D.29013;
}


verify_valuetype_layout_with_target (struct MonoClass * class, struct MonoClass * target_class)
{
  unsigned char D.29015;
  unsigned char D.29016;
  gboolean D.29019;
  unsigned char D.29020;
  unsigned int type.156;
  unsigned int D.29022;
  _Bool D.29023;
  unsigned int D.29024;
  _Bool D.29025;
  _Bool D.29026;
  struct MonoType * D.29029;
  short unsigned int D.29032;
  int D.29033;
  int D.29034;
  struct MonoClass * D.29037;
  _Bool D.29040;
  _Bool D.29041;
  _Bool D.29042;
  int D.29044;
  int type;
  void * iter;
  struct MonoClassField * field;
  struct MonoClass * field_class;

  try
    {
      iter = 0B;
      D.29015 = BIT_FIELD_REF <*class, 8, 160>;
      D.29016 = D.29015 & 8;
      if (D.29016 == 0) goto <D.29017>; else goto <D.29018>;
      <D.29017>:
      D.29019 = 1;
      return D.29019;
      <D.29018>:
      D.29020 = class->byval_arg.type;
      type = (int) D.29020;
      type.156 = (unsigned int) type;
      D.29022 = type.156 + 4294967294;
      D.29023 = D.29022 <= 11;
      type.156 = (unsigned int) type;
      D.29024 = type.156 + 4294967272;
      D.29025 = D.29024 <= 1;
      D.29026 = D.29023 | D.29025;
      if (D.29026 != 0) goto <D.29027>; else goto <D.29028>;
      <D.29027>:
      D.29019 = 1;
      return D.29019;
      <D.29028>:
      goto <D.22121>;
      <D.22122>:
      D.29029 = field->type;
      if (D.29029 == 0B) goto <D.29030>; else goto <D.29031>;
      <D.29030>:
      D.29019 = 0;
      return D.29019;
      <D.29031>:
      D.29029 = field->type;
      D.29032 = D.29029->attrs;
      D.29033 = (int) D.29032;
      D.29034 = D.29033 & 272;
      if (D.29034 != 0) goto <D.29035>; else goto <D.29036>;
      <D.29035>:
      // predicted unlikely by continue predictor.
      goto <D.22121>;
      <D.29036>:
      D.29029 = field->type;
      D.29037 = mono_class_from_mono_type (D.29029);
      field_class = mono_class_get_generic_type_definition (D.29037);
      D.29040 = field_class == target_class;
      D.29041 = class == field_class;
      D.29042 = D.29040 | D.29041;
      if (D.29042 != 0) goto <D.29038>; else goto <D.29043>;
      <D.29043>:
      D.29044 = verify_valuetype_layout_with_target (field_class, target_class);
      if (D.29044 == 0) goto <D.29038>; else goto <D.29039>;
      <D.29038>:
      D.29019 = 0;
      return D.29019;
      <D.29039>:
      <D.22121>:
      field = mono_class_get_fields (class, &iter);
      if (field != 0B) goto <D.22122>; else goto <D.22123>;
      <D.22123>:
      D.29019 = 1;
      return D.29019;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


verify_interfaces (struct MonoClass * class)
{
  struct MonoClass * * D.29047;
  unsigned int i.157;
  unsigned int D.29049;
  struct MonoClass * * D.29050;
  unsigned int D.29051;
  unsigned int D.29052;
  gboolean D.29055;
  short unsigned int D.29056;
  int D.29057;
  int i;

  i = 0;
  goto <D.22111>;
  <D.22110>:
  {
    struct MonoClass * iface;

    D.29047 = class->interfaces;
    i.157 = (unsigned int) i;
    D.29049 = i.157 * 4;
    D.29050 = D.29047 + D.29049;
    iface = *D.29050;
    D.29051 = iface->flags;
    D.29052 = D.29051 & 32;
    if (D.29052 == 0) goto <D.29053>; else goto <D.29054>;
    <D.29053>:
    D.29055 = 0;
    return D.29055;
    <D.29054>:
  }
  i = i + 1;
  <D.22111>:
  D.29056 = class->interface_count;
  D.29057 = (int) D.29056;
  if (D.29057 > i) goto <D.22110>; else goto <D.22112>;
  <D.22112>:
  D.29055 = 1;
  return D.29055;
}


mono_verifier_class_is_valid_generic_instantiation (struct MonoClass * class)
{
  gboolean D.29059;

  D.29059 = mono_class_is_valid_generic_instantiation (0B, class);
  return D.29059;
}


mono_verifier_is_method_valid_generic_instantiation (struct MonoMethod * method)
{
  unsigned char D.29061;
  unsigned char D.29062;
  gboolean D.29065;

  D.29061 = BIT_FIELD_REF <*method, 8, 168>;
  D.29062 = D.29061 & 16;
  if (D.29062 == 0) goto <D.29063>; else goto <D.29064>;
  <D.29063>:
  D.29065 = 1;
  return D.29065;
  <D.29064>:
  D.29065 = mono_method_is_valid_generic_instantiation (0B, method);
  return D.29065;
}