__attribute__((visibility ("hidden")))
mono_inst_set_src_registers (struct MonoInst * ins, int * regs)
{
  int D.28427;
  int D.28428;
  int D.28429;

  D.28427 = *regs;
  ins->sreg1 = D.28427;
  D.28428 = MEM[(int *)regs + 4B];
  ins->sreg2 = D.28428;
  D.28429 = MEM[(int *)regs + 8B];
  ins->sreg3 = D.28429;
}


__attribute__((visibility ("hidden")))
mono_alloc_ireg (struct MonoCompile * cfg)
{
  guint32 D.28430;

  D.28430 = alloc_ireg (cfg);
  return D.28430;
}


alloc_ireg (struct MonoCompile * cfg)
{
  guint32 D.28432;
  unsigned int D.28433;
  unsigned int D.28434;
  unsigned int D.28435;

  D.28433 = cfg->next_vreg;
  D.28434 = D.28433;
  D.28435 = D.28434 + 1;
  cfg->next_vreg = D.28435;
  D.28432 = D.28434;
  return D.28432;
}


__attribute__((visibility ("hidden")))
mono_alloc_freg (struct MonoCompile * cfg)
{
  guint32 D.28437;

  D.28437 = alloc_freg (cfg);
  return D.28437;
}


alloc_freg (struct MonoCompile * cfg)
{
  int D.28439;
  guint32 D.28442;
  unsigned int D.28443;
  unsigned int D.28444;
  unsigned int D.28445;

  D.28439 = mono_arch_is_soft_float ();
  if (D.28439 != 0) goto <D.28440>; else goto <D.28441>;
  <D.28440>:
  D.28442 = alloc_lreg (cfg);
  return D.28442;
  <D.28441>:
  D.28443 = cfg->next_vreg;
  D.28444 = D.28443;
  D.28445 = D.28444 + 1;
  cfg->next_vreg = D.28445;
  D.28442 = D.28444;
  return D.28442;
}


__attribute__((always_inline))
mono_arch_is_soft_float ()
{
  gboolean D.28447;

  D.28447 = 0;
  return D.28447;
}


alloc_lreg (struct MonoCompile * cfg)
{
  guint32 D.28449;
  unsigned int D.28450;
  unsigned int D.28451;
  unsigned int D.28452;

  D.28450 = cfg->next_vreg;
  D.28451 = D.28450;
  D.28452 = D.28451 + 1;
  cfg->next_vreg = D.28452;
  D.28449 = D.28451;
  return D.28449;
}


__attribute__((visibility ("hidden")))
mono_alloc_preg (struct MonoCompile * cfg)
{
  guint32 D.28454;

  D.28454 = alloc_preg (cfg);
  return D.28454;
}


alloc_preg (struct MonoCompile * cfg)
{
  guint32 D.28456;

  D.28456 = alloc_ireg (cfg);
  return D.28456;
}


__attribute__((visibility ("hidden")))
mono_alloc_dreg (struct MonoCompile * cfg, MonoStackType stack_type)
{
  guint32 D.28458;

  D.28458 = alloc_dreg (cfg, stack_type);
  return D.28458;
}


alloc_dreg (struct MonoCompile * cfg, MonoStackType stack_type)
{
  guint32 D.28460;

  switch (stack_type) <default: <D.24668>, case 1: <D.24661>, case 2: <D.24666>, case 3: <D.24662>, case 4: <D.24665>, case 5: <D.24663>, case 6: <D.24664>, case 7: <D.24667>>
  <D.24661>:
  <D.24662>:
  D.28460 = alloc_ireg (cfg);
  return D.28460;
  <D.24663>:
  D.28460 = alloc_ireg_mp (cfg);
  return D.28460;
  <D.24664>:
  D.28460 = alloc_ireg_ref (cfg);
  return D.28460;
  <D.24665>:
  D.28460 = alloc_freg (cfg);
  return D.28460;
  <D.24666>:
  D.28460 = alloc_lreg (cfg);
  return D.28460;
  <D.24667>:
  D.28460 = alloc_ireg (cfg);
  return D.28460;
  <D.24668>:
  monoeg_g_log (0B, 16, "Unknown stack type %x\n", stack_type);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "ir-emit.h", 97);
  D.28460 = 4294967295;
  return D.28460;
}


alloc_ireg_mp (struct MonoCompile * cfg)
{
  unsigned int D.28462;
  long unsigned int D.28463;
  long unsigned int D.28464;
  guint32 D.28467;
  int vreg;

  D.28462 = alloc_ireg (cfg);
  vreg = (int) D.28462;
  D.28463 = BIT_FIELD_REF <*cfg, 64, 5632>;
  D.28464 = D.28463 & 72057594037927936;
  if (D.28464 != 0) goto <D.28465>; else goto <D.28466>;
  <D.28465>:
  mono_mark_vreg_as_mp (cfg, vreg);
  <D.28466>:
  D.28467 = (guint32) vreg;
  return D.28467;
}


alloc_ireg_ref (struct MonoCompile * cfg)
{
  unsigned int D.28469;
  long unsigned int D.28470;
  long unsigned int D.28471;
  guint32 D.28474;
  int vreg;

  D.28469 = alloc_ireg (cfg);
  vreg = (int) D.28469;
  D.28470 = BIT_FIELD_REF <*cfg, 64, 5632>;
  D.28471 = D.28470 & 72057594037927936;
  if (D.28471 != 0) goto <D.28472>; else goto <D.28473>;
  <D.28472>:
  mono_mark_vreg_as_ref (cfg, vreg);
  <D.28473>:
  D.28474 = (guint32) vreg;
  return D.28474;
}


__attribute__((visibility ("hidden")))
mono_alloc_ireg_ref (struct MonoCompile * cfg)
{
  guint32 D.28476;

  D.28476 = alloc_ireg_ref (cfg);
  return D.28476;
}


__attribute__((visibility ("hidden")))
mono_alloc_ireg_mp (struct MonoCompile * cfg)
{
  guint32 D.28478;

  D.28478 = alloc_ireg_mp (cfg);
  return D.28478;
}


__attribute__((visibility ("hidden")))
mono_alloc_ireg_copy (struct MonoCompile * cfg, guint32 vreg)
{
  unsigned int D.28481;
  gboolean * D.28483;
  long unsigned int D.28484;
  long unsigned int D.28485;
  gboolean * D.28486;
  int D.28487;
  guint32 D.28489;
  unsigned int D.28491;
  gboolean * D.28493;
  gboolean * D.28494;
  int D.28495;

  D.28481 = cfg->vreg_is_ref_len;
  if (D.28481 > vreg) goto <D.28482>; else goto <D.28480>;
  <D.28482>:
  D.28483 = cfg->vreg_is_ref;
  D.28484 = (long unsigned int) vreg;
  D.28485 = D.28484 * 4;
  D.28486 = D.28483 + D.28485;
  D.28487 = *D.28486;
  if (D.28487 != 0) goto <D.28488>; else goto <D.28480>;
  <D.28488>:
  D.28489 = alloc_ireg_ref (cfg);
  return D.28489;
  <D.28480>:
  D.28491 = cfg->vreg_is_mp_len;
  if (D.28491 > vreg) goto <D.28492>; else goto <D.28490>;
  <D.28492>:
  D.28493 = cfg->vreg_is_mp;
  D.28484 = (long unsigned int) vreg;
  D.28485 = D.28484 * 4;
  D.28494 = D.28493 + D.28485;
  D.28495 = *D.28494;
  if (D.28495 != 0) goto <D.28496>; else goto <D.28490>;
  <D.28496>:
  D.28489 = alloc_ireg_mp (cfg);
  return D.28489;
  <D.28490>:
  D.28489 = alloc_ireg (cfg);
  return D.28489;
}


__attribute__((visibility ("hidden")))
mono_type_to_regmove (struct MonoCompile * cfg, struct MonoType * type)
{
  long unsigned int D.28498;
  long unsigned int D.28499;
  guint D.28502;
  unsigned char D.28503;
  int D.28504;
  struct MonoClass * D.28505;
  long unsigned int D.28506;
  long unsigned int D.28507;
  struct MonoGenericClass * D.28512;
  struct MonoClass * D.28513;
  struct MonoGenericSharingContext * D.28514;
  _Bool D.28515;
  long int D.28516;
  long int D.28517;
  int D.28520;
  void handle_enum = <<< error >>>;

  D.28498 = BIT_FIELD_REF <*type, 64, 64>;
  D.28499 = D.28498 & 8589934592;
  if (D.28499 != 0) goto <D.28500>; else goto <D.28501>;
  <D.28500>:
  D.28502 = 424;
  return D.28502;
  <D.28501>:
  type = mini_replace_type (type);
  handle_enum:
  D.28503 = type->type;
  D.28504 = (int) D.28503;
  switch (D.28504) <default: <D.25034>, case 2: <D.25010>, case 3: <D.25013>, case 4: <D.25008>, case 5: <D.25009>, case 6: <D.25011>, case 7: <D.25012>, case 8: <D.25014>, case 9: <D.25015>, case 10: <D.25025>, case 11: <D.25026>, case 12: <D.25027>, case 13: <D.25028>, case 14: <D.25021>, case 15: <D.25018>, case 17: <D.25029>, case 18: <D.25020>, case 19: <D.25032>, case 20: <D.25024>, case 21: <D.25031>, case 22: <D.25030>, case 24: <D.25016>, case 25: <D.25017>, case 27: <D.25019>, case 28: <D.25022>, case 29: <D.25023>, case 30: <D.25033>>
  <D.25008>:
  <D.25009>:
  <D.25010>:
  D.28502 = 424;
  return D.28502;
  <D.25011>:
  <D.25012>:
  <D.25013>:
  D.28502 = 424;
  return D.28502;
  <D.25014>:
  <D.25015>:
  D.28502 = 424;
  return D.28502;
  <D.25016>:
  <D.25017>:
  <D.25018>:
  <D.25019>:
  D.28502 = 424;
  return D.28502;
  <D.25020>:
  <D.25021>:
  <D.25022>:
  <D.25023>:
  <D.25024>:
  D.28502 = 424;
  return D.28502;
  <D.25025>:
  <D.25026>:
  D.28502 = 424;
  return D.28502;
  <D.25027>:
  D.28502 = 426;
  return D.28502;
  <D.25028>:
  D.28502 = 426;
  return D.28502;
  <D.25029>:
  D.28505 = type->data.klass;
  D.28506 = BIT_FIELD_REF <*D.28505, 64, 256>;
  D.28507 = D.28506 & 576460752303423488;
  if (D.28507 != 0) goto <D.28508>; else goto <D.28509>;
  <D.28508>:
  D.28505 = type->data.klass;
  type = mono_class_enum_basetype (D.28505);
  goto handle_enum;
  <D.28509>:
  if (0 != 0) goto <D.28510>; else goto <D.28511>;
  <D.28510>:
  D.28502 = 800;
  return D.28502;
  <D.28511>:
  D.28502 = 427;
  return D.28502;
  <D.25030>:
  D.28502 = 427;
  return D.28502;
  <D.25031>:
  D.28512 = type->data.generic_class;
  D.28513 = D.28512->container_class;
  type = &D.28513->byval_arg;
  goto handle_enum;
  <D.25032>:
  <D.25033>:
  D.28514 = cfg->generic_sharing_context;
  D.28515 = D.28514 == 0B;
  D.28516 = (long int) D.28515;
  D.28517 = __builtin_expect (D.28516, 0);
  if (D.28517 != 0) goto <D.28518>; else goto <D.28519>;
  <D.28518>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 324, "cfg->generic_sharing_context");
  <D.28519>:
  D.28520 = mini_type_var_is_vt (cfg, type);
  if (D.28520 != 0) goto <D.28521>; else goto <D.28522>;
  <D.28521>:
  D.28502 = 427;
  return D.28502;
  <D.28522>:
  D.28502 = 424;
  return D.28502;
  <D.25034>:
  D.28503 = type->type;
  D.28504 = (int) D.28503;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in type_to_regstore", D.28504);
  <D.25035>:
  goto <D.25035>;
  D.28502 = 4294967295;
  return D.28502;
}


__attribute__((visibility ("hidden")))
mono_print_bb (struct MonoBasicBlock * bb, const char * msg)
{
  int D.28524;
  struct MonoBasicBlock * * D.28525;
  long unsigned int D.28526;
  long unsigned int D.28527;
  struct MonoBasicBlock * * D.28528;
  struct MonoBasicBlock * D.28529;
  int D.28530;
  int D.28531;
  short int D.28532;
  int D.28533;
  struct MonoBasicBlock * * D.28534;
  struct MonoBasicBlock * * D.28535;
  struct MonoBasicBlock * D.28536;
  int D.28537;
  int D.28538;
  short int D.28539;
  int D.28540;
  int i;
  struct MonoInst * tree;

  D.28524 = bb->block_num;
  printf ("\n%s %d: [IN: ", msg, D.28524);
  i = 0;
  goto <D.25043>;
  <D.25042>:
  D.28525 = bb->in_bb;
  D.28526 = (long unsigned int) i;
  D.28527 = D.28526 * 8;
  D.28528 = D.28525 + D.28527;
  D.28529 = *D.28528;
  D.28530 = D.28529->block_num;
  D.28525 = bb->in_bb;
  D.28526 = (long unsigned int) i;
  D.28527 = D.28526 * 8;
  D.28528 = D.28525 + D.28527;
  D.28529 = *D.28528;
  D.28531 = D.28529->dfn;
  printf (" BB%d(%d)", D.28530, D.28531);
  i = i + 1;
  <D.25043>:
  D.28532 = bb->in_count;
  D.28533 = (int) D.28532;
  if (D.28533 > i) goto <D.25042>; else goto <D.25044>;
  <D.25044>:
  printf (", OUT: ");
  i = 0;
  goto <D.25046>;
  <D.25045>:
  D.28534 = bb->out_bb;
  D.28526 = (long unsigned int) i;
  D.28527 = D.28526 * 8;
  D.28535 = D.28534 + D.28527;
  D.28536 = *D.28535;
  D.28537 = D.28536->block_num;
  D.28534 = bb->out_bb;
  D.28526 = (long unsigned int) i;
  D.28527 = D.28526 * 8;
  D.28535 = D.28534 + D.28527;
  D.28536 = *D.28535;
  D.28538 = D.28536->dfn;
  printf (" BB%d(%d)", D.28537, D.28538);
  i = i + 1;
  <D.25046>:
  D.28539 = bb->out_count;
  D.28540 = (int) D.28539;
  if (D.28540 > i) goto <D.25045>; else goto <D.25047>;
  <D.25047>:
  printf (" ]\n");
  tree = bb->code;
  goto <D.25049>;
  <D.25048>:
  mono_print_ins_index (-1, tree);
  tree = tree->next;
  <D.25049>:
  if (tree != 0B) goto <D.25048>; else goto <D.25050>;
  <D.25050>:
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
printf (const char * restrict __fmt)
{
  int D.28541;

  D.28541 = __printf_chk (1, __fmt, __builtin_va_arg_pack ());
  return D.28541;
}


__attribute__((visibility ("hidden")))
mono_create_helper_signatures ()
{
  struct MonoMethodSignature * D.28543;
  struct MonoMethodSignature * D.28544;
  struct MonoMethodSignature * D.28545;
  struct MonoMethodSignature * D.28546;
  struct MonoMethodSignature * D.28547;
  struct MonoMethodSignature * D.28548;
  struct MonoMethodSignature * D.28549;

  D.28543 = mono_create_icall_signature ("ptr");
  helper_sig_domain_get = D.28543;
  D.28544 = mono_create_icall_signature ("void");
  helper_sig_class_init_trampoline = D.28544;
  D.28545 = mono_create_icall_signature ("void");
  helper_sig_generic_class_init_trampoline = D.28545;
  D.28546 = mono_create_icall_signature ("void ptr");
  helper_sig_generic_class_init_trampoline_llvm = D.28546;
  D.28547 = mono_create_icall_signature ("ptr ptr");
  helper_sig_rgctx_lazy_fetch_trampoline = D.28547;
  D.28548 = mono_create_icall_signature ("void");
  helper_sig_monitor_enter_exit_trampoline = D.28548;
  D.28549 = mono_create_icall_signature ("void object");
  helper_sig_monitor_enter_exit_trampoline_llvm = D.28549;
}


__attribute__((visibility ("hidden")))
mono_link_bblock (struct MonoCompile * cfg, struct MonoBasicBlock * from, struct MonoBasicBlock * to)
{
  link_bblock (cfg, from, to);
}


link_bblock (struct MonoCompile * cfg, struct MonoBasicBlock * from, struct MonoBasicBlock * to)
{
  struct MonoBasicBlock * * D.28550;
  long unsigned int D.28551;
  long unsigned int D.28552;
  struct MonoBasicBlock * * D.28553;
  struct MonoBasicBlock * D.28554;
  short int D.28557;
  int D.28558;
  struct MonoMemPool * D.28561;
  int D.28562;
  long unsigned int D.28563;
  unsigned int D.28564;
  unsigned int D.28565;
  struct MonoBasicBlock * * D.28566;
  short int D.28567;
  unsigned short D.28568;
  unsigned short D.28569;
  short int D.28570;
  struct MonoBasicBlock * * D.28571;
  struct MonoBasicBlock * * D.28572;
  struct MonoBasicBlock * D.28573;
  short int D.28576;
  int D.28577;
  int D.28580;
  long unsigned int D.28581;
  unsigned int D.28582;
  unsigned int D.28583;
  short int D.28584;
  unsigned short D.28585;
  unsigned short D.28586;
  short int D.28587;
  struct MonoBasicBlock * * newa;
  int i;
  int found;

  found = 0;
  i = 0;
  goto <D.25064>;
  <D.25063>:
  D.28550 = from->out_bb;
  D.28551 = (long unsigned int) i;
  D.28552 = D.28551 * 8;
  D.28553 = D.28550 + D.28552;
  D.28554 = *D.28553;
  if (D.28554 == to) goto <D.28555>; else goto <D.28556>;
  <D.28555>:
  found = 1;
  goto <D.25062>;
  <D.28556>:
  i = i + 1;
  <D.25064>:
  D.28557 = from->out_count;
  D.28558 = (int) D.28557;
  if (D.28558 > i) goto <D.25063>; else goto <D.25062>;
  <D.25062>:
  if (found == 0) goto <D.28559>; else goto <D.28560>;
  <D.28559>:
  D.28561 = cfg->mempool;
  D.28557 = from->out_count;
  D.28558 = (int) D.28557;
  D.28562 = D.28558 + 1;
  D.28563 = (long unsigned int) D.28562;
  D.28564 = (unsigned int) D.28563;
  D.28565 = D.28564 * 8;
  newa = mono_mempool_alloc (D.28561, D.28565);
  i = 0;
  goto <D.25066>;
  <D.25065>:
  D.28551 = (long unsigned int) i;
  D.28552 = D.28551 * 8;
  D.28566 = newa + D.28552;
  D.28550 = from->out_bb;
  D.28551 = (long unsigned int) i;
  D.28552 = D.28551 * 8;
  D.28553 = D.28550 + D.28552;
  D.28554 = *D.28553;
  *D.28566 = D.28554;
  i = i + 1;
  <D.25066>:
  D.28557 = from->out_count;
  D.28558 = (int) D.28557;
  if (D.28558 > i) goto <D.25065>; else goto <D.25067>;
  <D.25067>:
  D.28551 = (long unsigned int) i;
  D.28552 = D.28551 * 8;
  D.28566 = newa + D.28552;
  *D.28566 = to;
  D.28557 = from->out_count;
  D.28567 = D.28557;
  D.28568 = (unsigned short) D.28567;
  D.28569 = D.28568 + 1;
  D.28570 = (short int) D.28569;
  from->out_count = D.28570;
  from->out_bb = newa;
  <D.28560>:
  found = 0;
  i = 0;
  goto <D.25070>;
  <D.25069>:
  D.28571 = to->in_bb;
  D.28551 = (long unsigned int) i;
  D.28552 = D.28551 * 8;
  D.28572 = D.28571 + D.28552;
  D.28573 = *D.28572;
  if (D.28573 == from) goto <D.28574>; else goto <D.28575>;
  <D.28574>:
  found = 1;
  goto <D.25068>;
  <D.28575>:
  i = i + 1;
  <D.25070>:
  D.28576 = to->in_count;
  D.28577 = (int) D.28576;
  if (D.28577 > i) goto <D.25069>; else goto <D.25068>;
  <D.25068>:
  if (found == 0) goto <D.28578>; else goto <D.28579>;
  <D.28578>:
  D.28561 = cfg->mempool;
  D.28576 = to->in_count;
  D.28577 = (int) D.28576;
  D.28580 = D.28577 + 1;
  D.28581 = (long unsigned int) D.28580;
  D.28582 = (unsigned int) D.28581;
  D.28583 = D.28582 * 8;
  newa = mono_mempool_alloc (D.28561, D.28583);
  i = 0;
  goto <D.25072>;
  <D.25071>:
  D.28551 = (long unsigned int) i;
  D.28552 = D.28551 * 8;
  D.28566 = newa + D.28552;
  D.28571 = to->in_bb;
  D.28551 = (long unsigned int) i;
  D.28552 = D.28551 * 8;
  D.28572 = D.28571 + D.28552;
  D.28573 = *D.28572;
  *D.28566 = D.28573;
  i = i + 1;
  <D.25072>:
  D.28576 = to->in_count;
  D.28577 = (int) D.28576;
  if (D.28577 > i) goto <D.25071>; else goto <D.25073>;
  <D.25073>:
  D.28551 = (long unsigned int) i;
  D.28552 = D.28551 * 8;
  D.28566 = newa + D.28552;
  *D.28566 = from;
  D.28576 = to->in_count;
  D.28584 = D.28576;
  D.28585 = (unsigned short) D.28584;
  D.28586 = D.28585 + 1;
  D.28587 = (short int) D.28586;
  to->in_count = D.28587;
  to->in_bb = newa;
  <D.28579>:
}


__attribute__((visibility ("hidden")))
mono_find_exvar_for_offset (struct MonoCompile * cfg, int offset)
{
  struct MonoInst * D.28588;
  struct GHashTable * D.28589;
  long int D.28590;
  const void * D.28591;

  D.28589 = cfg->exvars;
  D.28590 = (long int) offset;
  D.28591 = (const void *) D.28590;
  D.28588 = monoeg_g_hash_table_lookup (D.28589, D.28591);
  return D.28588;
}


__attribute__((visibility ("hidden")))
type_to_eval_stack_type (struct MonoCompile * cfg, struct MonoType * type, struct MonoInst * inst)
{
  long unsigned int D.28593;
  long unsigned int D.28594;
  unsigned char D.28597;
  int D.28598;
  struct MonoClass * D.28599;
  long unsigned int D.28600;
  long unsigned int D.28601;
  struct MonoClass * D.28604;
  struct MonoGenericClass * D.28605;
  struct MonoClass * D.28606;
  struct MonoGenericSharingContext * D.28607;
  _Bool D.28608;
  long int D.28609;
  long int D.28610;
  int D.28613;
  int D.28616;
  _Bool D.28617;
  long int D.28618;
  long int D.28619;
  struct MonoClass * klass;
  void handle_enum = <<< error >>>;

  type = mini_replace_type (type);
  klass = mono_class_from_mono_type (type);
  inst->klass = klass;
  D.28593 = BIT_FIELD_REF <*type, 64, 64>;
  D.28594 = D.28593 & 8589934592;
  if (D.28594 != 0) goto <D.28595>; else goto <D.28596>;
  <D.28595>:
  inst->type = 5;
  return;
  <D.28596>:
  handle_enum:
  D.28597 = type->type;
  D.28598 = (int) D.28597;
  switch (D.28598) <default: <D.25150>, case 1: <D.25123>, case 2: <D.25126>, case 3: <D.25129>, case 4: <D.25124>, case 5: <D.25125>, case 6: <D.25127>, case 7: <D.25128>, case 8: <D.25130>, case 9: <D.25131>, case 10: <D.25141>, case 11: <D.25142>, case 12: <D.25143>, case 13: <D.25144>, case 14: <D.25137>, case 15: <D.25134>, case 17: <D.25145>, case 18: <D.25136>, case 19: <D.25148>, case 20: <D.25140>, case 21: <D.25147>, case 22: <D.25146>, case 24: <D.25132>, case 25: <D.25133>, case 27: <D.25135>, case 28: <D.25138>, case 29: <D.25139>, case 30: <D.25149>>
  <D.25123>:
  inst->type = 0;
  return;
  <D.25124>:
  <D.25125>:
  <D.25126>:
  <D.25127>:
  <D.25128>:
  <D.25129>:
  <D.25130>:
  <D.25131>:
  inst->type = 1;
  return;
  <D.25132>:
  <D.25133>:
  <D.25134>:
  <D.25135>:
  inst->type = 3;
  return;
  <D.25136>:
  <D.25137>:
  <D.25138>:
  <D.25139>:
  <D.25140>:
  inst->type = 6;
  return;
  <D.25141>:
  <D.25142>:
  inst->type = 2;
  return;
  <D.25143>:
  <D.25144>:
  inst->type = 4;
  return;
  <D.25145>:
  D.28599 = type->data.klass;
  D.28600 = BIT_FIELD_REF <*D.28599, 64, 256>;
  D.28601 = D.28600 & 576460752303423488;
  if (D.28601 != 0) goto <D.28602>; else goto <D.28603>;
  <D.28602>:
  D.28599 = type->data.klass;
  type = mono_class_enum_basetype (D.28599);
  goto handle_enum;
  <D.28603>:
  inst->klass = klass;
  inst->type = 7;
  return;
  <D.25146>:
  D.28604 = mono_defaults.typed_reference_class;
  inst->klass = D.28604;
  inst->type = 7;
  return;
  <D.25147>:
  D.28605 = type->data.generic_class;
  D.28606 = D.28605->container_class;
  type = &D.28606->byval_arg;
  goto handle_enum;
  <D.25148>:
  <D.25149>:
  D.28607 = cfg->generic_sharing_context;
  D.28608 = D.28607 == 0B;
  D.28609 = (long int) D.28608;
  D.28610 = __builtin_expect (D.28609, 0);
  if (D.28610 != 0) goto <D.28611>; else goto <D.28612>;
  <D.28611>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 717, "cfg->generic_sharing_context");
  <D.28612>:
  D.28613 = mini_is_gsharedvt_type (cfg, type);
  if (D.28613 != 0) goto <D.28614>; else goto <D.28615>;
  <D.28614>:
  D.28616 = cfg->gsharedvt;
  D.28617 = D.28616 == 0;
  D.28618 = (long int) D.28617;
  D.28619 = __builtin_expect (D.28618, 0);
  if (D.28619 != 0) goto <D.28620>; else goto <D.28621>;
  <D.28620>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 719, "cfg->gsharedvt");
  <D.28621>:
  inst->type = 7;
  goto <D.28622>;
  <D.28615>:
  inst->type = 6;
  <D.28622>:
  return;
  <D.25150>:
  D.28597 = type->type;
  D.28598 = (int) D.28597;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in eval stack type", D.28598);
  <D.25151>:
  goto <D.25151>;
}


__attribute__((visibility ("hidden")))
mono_get_got_var (struct MonoCompile * cfg)
{
  struct MonoInst * D.28624;

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


__attribute__((visibility ("hidden")))
mini_emit_memcpy (struct MonoCompile * cfg, int destreg, int doffset, int srcreg, int soffset, int size, int align)
{
  _Bool D.28628;
  long int D.28629;
  long int D.28630;
  unsigned int D.28635;
  struct MonoMemPool * D.28636;
  long int D.28637;
  struct MonoInst * D.28638;
  int D.28639;
  int D.28640;
  const unsigned char * D.28641;
  long int D.28642;
  struct MonoBasicBlock * D.28643;
  struct MonoInst * D.28644;
  long int D.28648;
  struct MonoInst * D.28649;
  int D.28650;
  int D.28651;
  long int D.28652;
  unsigned int D.28658;
  long int D.28659;
  struct MonoInst * D.28660;
  int D.28661;
  int D.28662;
  long int D.28666;
  struct MonoInst * D.28667;
  int D.28668;
  int D.28669;
  unsigned int D.28673;
  long int D.28674;
  struct MonoInst * D.28675;
  int D.28676;
  int D.28677;
  long int D.28681;
  struct MonoInst * D.28682;
  int D.28683;
  int D.28684;
  unsigned int D.28688;
  long int D.28689;
  struct MonoInst * D.28690;
  int D.28691;
  int D.28692;
  long int D.28696;
  struct MonoInst * D.28697;
  int D.28698;
  int D.28699;
  unsigned int D.28703;
  long int D.28704;
  struct MonoInst * D.28705;
  int D.28706;
  int D.28707;
  long int D.28711;
  struct MonoInst * D.28712;
  int D.28713;
  int D.28714;
  int cur_reg;

  if (align == 0) goto <D.28626>; else goto <D.28627>;
  <D.28626>:
  align = 4;
  <D.28627>:
  D.28628 = size > 9999;
  D.28629 = (long int) D.28628;
  D.28630 = __builtin_expect (D.28629, 0);
  if (D.28630 != 0) goto <D.28631>; else goto <D.28632>;
  <D.28631>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1826, "size < 10000");
  <D.28632>:
  if (align <= 3) goto <D.28633>; else goto <D.28634>;
  <D.28633>:
  goto <D.25655>;
  <D.25654>:
  D.28635 = alloc_preg (cfg);
  cur_reg = (int) D.28635;
  {
    struct MonoInst * inst;

    D.28636 = cfg->mempool;
    inst = mono_mempool_alloc (D.28636, 80);
    inst->data.op[1].const_val = 0;
    D.28637 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.28637;
    inst->prev = 0B;
    D.28638 = inst->prev;
    inst->next = D.28638;
    inst->opcode = 389;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.28639 = inst->sreg3;
    inst->sreg2 = D.28639;
    D.28640 = inst->sreg2;
    inst->sreg1 = D.28640;
    D.28641 = cfg->ip;
    inst->cil_code = D.28641;
    inst->dreg = cur_reg;
    inst->sreg1 = srcreg;
    D.28642 = (long int) soffset;
    inst->data.op[0].const_val = D.28642;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    if (D.28644 != 0B) goto <D.28645>; else goto <D.28646>;
    <D.28645>:
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    D.28644->next = inst;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    inst->prev = D.28644;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    goto <D.28647>;
    <D.28646>:
    D.28643 = cfg->cbb;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    D.28644 = D.28643->last_ins;
    D.28643->code = D.28644;
    <D.28647>:
  }
  {
    struct MonoInst * inst;

    D.28636 = cfg->mempool;
    inst = mono_mempool_alloc (D.28636, 80);
    inst->data.op[1].const_val = 0;
    D.28648 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.28648;
    inst->prev = 0B;
    D.28649 = inst->prev;
    inst->next = D.28649;
    inst->opcode = 375;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.28650 = inst->sreg3;
    inst->sreg2 = D.28650;
    D.28651 = inst->sreg2;
    inst->sreg1 = D.28651;
    D.28641 = cfg->ip;
    inst->cil_code = D.28641;
    inst->sreg1 = cur_reg;
    inst->dreg = destreg;
    D.28652 = (long int) doffset;
    inst->data.op[0].const_val = D.28652;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    if (D.28644 != 0B) goto <D.28653>; else goto <D.28654>;
    <D.28653>:
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    D.28644->next = inst;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    inst->prev = D.28644;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    goto <D.28655>;
    <D.28654>:
    D.28643 = cfg->cbb;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    D.28644 = D.28643->last_ins;
    D.28643->code = D.28644;
    <D.28655>:
  }
  doffset = doffset + 1;
  soffset = soffset + 1;
  size = size + -1;
  <D.25655>:
  if (size > 0) goto <D.25654>; else goto <D.25656>;
  <D.25656>:
  <D.28634>:
  if (1 != 0) goto <D.28656>; else goto <D.28657>;
  <D.28656>:
  goto <D.25660>;
  <D.25659>:
  D.28658 = alloc_preg (cfg);
  cur_reg = (int) D.28658;
  {
    struct MonoInst * inst;

    D.28636 = cfg->mempool;
    inst = mono_mempool_alloc (D.28636, 80);
    inst->data.op[1].const_val = 0;
    D.28659 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.28659;
    inst->prev = 0B;
    D.28660 = inst->prev;
    inst->next = D.28660;
    inst->opcode = 395;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.28661 = inst->sreg3;
    inst->sreg2 = D.28661;
    D.28662 = inst->sreg2;
    inst->sreg1 = D.28662;
    D.28641 = cfg->ip;
    inst->cil_code = D.28641;
    inst->dreg = cur_reg;
    inst->sreg1 = srcreg;
    D.28642 = (long int) soffset;
    inst->data.op[0].const_val = D.28642;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    if (D.28644 != 0B) goto <D.28663>; else goto <D.28664>;
    <D.28663>:
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    D.28644->next = inst;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    inst->prev = D.28644;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    goto <D.28665>;
    <D.28664>:
    D.28643 = cfg->cbb;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    D.28644 = D.28643->last_ins;
    D.28643->code = D.28644;
    <D.28665>:
  }
  {
    struct MonoInst * inst;

    D.28636 = cfg->mempool;
    inst = mono_mempool_alloc (D.28636, 80);
    inst->data.op[1].const_val = 0;
    D.28666 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.28666;
    inst->prev = 0B;
    D.28667 = inst->prev;
    inst->next = D.28667;
    inst->opcode = 378;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.28668 = inst->sreg3;
    inst->sreg2 = D.28668;
    D.28669 = inst->sreg2;
    inst->sreg1 = D.28669;
    D.28641 = cfg->ip;
    inst->cil_code = D.28641;
    inst->sreg1 = cur_reg;
    inst->dreg = destreg;
    D.28652 = (long int) doffset;
    inst->data.op[0].const_val = D.28652;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    if (D.28644 != 0B) goto <D.28670>; else goto <D.28671>;
    <D.28670>:
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    D.28644->next = inst;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    inst->prev = D.28644;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    goto <D.28672>;
    <D.28671>:
    D.28643 = cfg->cbb;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    D.28644 = D.28643->last_ins;
    D.28643->code = D.28644;
    <D.28672>:
  }
  doffset = doffset + 8;
  soffset = soffset + 8;
  size = size + -8;
  <D.25660>:
  if (size > 7) goto <D.25659>; else goto <D.25661>;
  <D.25661>:
  <D.28657>:
  goto <D.25665>;
  <D.25664>:
  D.28673 = alloc_preg (cfg);
  cur_reg = (int) D.28673;
  {
    struct MonoInst * inst;

    D.28636 = cfg->mempool;
    inst = mono_mempool_alloc (D.28636, 80);
    inst->data.op[1].const_val = 0;
    D.28674 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.28674;
    inst->prev = 0B;
    D.28675 = inst->prev;
    inst->next = D.28675;
    inst->opcode = 393;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.28676 = inst->sreg3;
    inst->sreg2 = D.28676;
    D.28677 = inst->sreg2;
    inst->sreg1 = D.28677;
    D.28641 = cfg->ip;
    inst->cil_code = D.28641;
    inst->dreg = cur_reg;
    inst->sreg1 = srcreg;
    D.28642 = (long int) soffset;
    inst->data.op[0].const_val = D.28642;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    if (D.28644 != 0B) goto <D.28678>; else goto <D.28679>;
    <D.28678>:
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    D.28644->next = inst;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    inst->prev = D.28644;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    goto <D.28680>;
    <D.28679>:
    D.28643 = cfg->cbb;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    D.28644 = D.28643->last_ins;
    D.28643->code = D.28644;
    <D.28680>:
  }
  {
    struct MonoInst * inst;

    D.28636 = cfg->mempool;
    inst = mono_mempool_alloc (D.28636, 80);
    inst->data.op[1].const_val = 0;
    D.28681 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.28681;
    inst->prev = 0B;
    D.28682 = inst->prev;
    inst->next = D.28682;
    inst->opcode = 377;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.28683 = inst->sreg3;
    inst->sreg2 = D.28683;
    D.28684 = inst->sreg2;
    inst->sreg1 = D.28684;
    D.28641 = cfg->ip;
    inst->cil_code = D.28641;
    inst->sreg1 = cur_reg;
    inst->dreg = destreg;
    D.28652 = (long int) doffset;
    inst->data.op[0].const_val = D.28652;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    if (D.28644 != 0B) goto <D.28685>; else goto <D.28686>;
    <D.28685>:
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    D.28644->next = inst;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    inst->prev = D.28644;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    goto <D.28687>;
    <D.28686>:
    D.28643 = cfg->cbb;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    D.28644 = D.28643->last_ins;
    D.28643->code = D.28644;
    <D.28687>:
  }
  doffset = doffset + 4;
  soffset = soffset + 4;
  size = size + -4;
  <D.25665>:
  if (size > 3) goto <D.25664>; else goto <D.25666>;
  <D.25666>:
  goto <D.25670>;
  <D.25669>:
  D.28688 = alloc_preg (cfg);
  cur_reg = (int) D.28688;
  {
    struct MonoInst * inst;

    D.28636 = cfg->mempool;
    inst = mono_mempool_alloc (D.28636, 80);
    inst->data.op[1].const_val = 0;
    D.28689 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.28689;
    inst->prev = 0B;
    D.28690 = inst->prev;
    inst->next = D.28690;
    inst->opcode = 391;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.28691 = inst->sreg3;
    inst->sreg2 = D.28691;
    D.28692 = inst->sreg2;
    inst->sreg1 = D.28692;
    D.28641 = cfg->ip;
    inst->cil_code = D.28641;
    inst->dreg = cur_reg;
    inst->sreg1 = srcreg;
    D.28642 = (long int) soffset;
    inst->data.op[0].const_val = D.28642;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    if (D.28644 != 0B) goto <D.28693>; else goto <D.28694>;
    <D.28693>:
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    D.28644->next = inst;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    inst->prev = D.28644;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    goto <D.28695>;
    <D.28694>:
    D.28643 = cfg->cbb;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    D.28644 = D.28643->last_ins;
    D.28643->code = D.28644;
    <D.28695>:
  }
  {
    struct MonoInst * inst;

    D.28636 = cfg->mempool;
    inst = mono_mempool_alloc (D.28636, 80);
    inst->data.op[1].const_val = 0;
    D.28696 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.28696;
    inst->prev = 0B;
    D.28697 = inst->prev;
    inst->next = D.28697;
    inst->opcode = 376;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.28698 = inst->sreg3;
    inst->sreg2 = D.28698;
    D.28699 = inst->sreg2;
    inst->sreg1 = D.28699;
    D.28641 = cfg->ip;
    inst->cil_code = D.28641;
    inst->sreg1 = cur_reg;
    inst->dreg = destreg;
    D.28652 = (long int) doffset;
    inst->data.op[0].const_val = D.28652;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    if (D.28644 != 0B) goto <D.28700>; else goto <D.28701>;
    <D.28700>:
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    D.28644->next = inst;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    inst->prev = D.28644;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    goto <D.28702>;
    <D.28701>:
    D.28643 = cfg->cbb;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    D.28644 = D.28643->last_ins;
    D.28643->code = D.28644;
    <D.28702>:
  }
  doffset = doffset + 2;
  soffset = soffset + 2;
  size = size + -2;
  <D.25670>:
  if (size > 1) goto <D.25669>; else goto <D.25671>;
  <D.25671>:
  goto <D.25675>;
  <D.25674>:
  D.28703 = alloc_preg (cfg);
  cur_reg = (int) D.28703;
  {
    struct MonoInst * inst;

    D.28636 = cfg->mempool;
    inst = mono_mempool_alloc (D.28636, 80);
    inst->data.op[1].const_val = 0;
    D.28704 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.28704;
    inst->prev = 0B;
    D.28705 = inst->prev;
    inst->next = D.28705;
    inst->opcode = 389;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.28706 = inst->sreg3;
    inst->sreg2 = D.28706;
    D.28707 = inst->sreg2;
    inst->sreg1 = D.28707;
    D.28641 = cfg->ip;
    inst->cil_code = D.28641;
    inst->dreg = cur_reg;
    inst->sreg1 = srcreg;
    D.28642 = (long int) soffset;
    inst->data.op[0].const_val = D.28642;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    if (D.28644 != 0B) goto <D.28708>; else goto <D.28709>;
    <D.28708>:
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    D.28644->next = inst;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    inst->prev = D.28644;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    goto <D.28710>;
    <D.28709>:
    D.28643 = cfg->cbb;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    D.28644 = D.28643->last_ins;
    D.28643->code = D.28644;
    <D.28710>:
  }
  {
    struct MonoInst * inst;

    D.28636 = cfg->mempool;
    inst = mono_mempool_alloc (D.28636, 80);
    inst->data.op[1].const_val = 0;
    D.28711 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.28711;
    inst->prev = 0B;
    D.28712 = inst->prev;
    inst->next = D.28712;
    inst->opcode = 375;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.28713 = inst->sreg3;
    inst->sreg2 = D.28713;
    D.28714 = inst->sreg2;
    inst->sreg1 = D.28714;
    D.28641 = cfg->ip;
    inst->cil_code = D.28641;
    inst->sreg1 = cur_reg;
    inst->dreg = destreg;
    D.28652 = (long int) doffset;
    inst->data.op[0].const_val = D.28652;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    if (D.28644 != 0B) goto <D.28715>; else goto <D.28716>;
    <D.28715>:
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    D.28644->next = inst;
    D.28643 = cfg->cbb;
    D.28644 = D.28643->last_ins;
    inst->prev = D.28644;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    goto <D.28717>;
    <D.28716>:
    D.28643 = cfg->cbb;
    D.28643 = cfg->cbb;
    D.28643->last_ins = inst;
    D.28644 = D.28643->last_ins;
    D.28643->code = D.28644;
    <D.28717>:
  }
  doffset = doffset + 1;
  soffset = soffset + 1;
  size = size + -1;
  <D.25675>:
  if (size > 0) goto <D.25674>; else goto <D.25676>;
  <D.25676>:
}


__attribute__((visibility ("hidden")))
mono_emit_method_call (struct MonoCompile * cfg, struct MonoMethod * method, struct MonoInst * * args, struct MonoInst * this)
{
  struct MonoInst * D.28718;
  struct MonoMethodSignature * D.28719;

  D.28719 = mono_method_signature (method);
  D.28718 = mono_emit_method_call_full (cfg, method, D.28719, 0, args, this, 0B, 0B);
  return D.28718;
}


mono_emit_method_call_full (struct MonoCompile * cfg, struct MonoMethod * method, struct MonoMethodSignature * sig, gboolean tail, struct MonoInst * * args, struct MonoInst * this, struct MonoInst * imt_arg, struct MonoInst * rgctx_arg)
{
  _Bool D.28721;
  unsigned int D.28726;
  struct MonoMemPool * D.28727;
  long int D.28728;
  struct MonoInst * D.28729;
  int D.28730;
  int D.28731;
  const unsigned char * D.28732;
  int D.28733;
  struct MonoBasicBlock * D.28734;
  struct MonoInst * D.28735;
  long unsigned int D.28739;
  long unsigned int D.28740;
  struct MonoClass * D.28743;
  struct MonoType * D.28744;
  int iftmp.0;
  long unsigned int D.28751;
  long unsigned int D.28752;
  struct MonoClass * D.28754;
  long unsigned int D.28755;
  long unsigned int D.28756;
  struct MonoClass * D.28758;
  short unsigned int D.28759;
  int D.28760;
  int D.28761;
  struct MonoMethod * D.28763;
  struct MonoMethodSignature * D.28764;
  long unsigned int D.28765;
  long unsigned int D.28766;
  short unsigned int D.28768;
  int D.28770;
  struct MonoInst * * D.28771;
  struct MonoInst * D.28772;
  int D.28773;
  struct MonoGenericSharingContext * D.28779;
  _Bool D.28780;
  long int D.28781;
  long int D.28782;
  struct MonoInst * D.28785;
  int iftmp.1;
  unsigned int D.28791;
  unsigned int D.28792;
  _Bool D.28793;
  int D.28794;
  struct MonoMethod * D.28797;
  unsigned char D.28799;
  unsigned char D.28800;
  unsigned char D.28801;
  <unnamed-unsigned:1> D.28802;
  struct MonoClass * D.28805;
  struct MonoClass * D.28806;
  const char * D.28809;
  int D.28810;
  long unsigned int D.28813;
  long unsigned int D.28814;
  long int D.28817;
  struct MonoInst * D.28818;
  int D.28819;
  int D.28820;
  long int D.28824;
  struct MonoInst * D.28825;
  int D.28826;
  int D.28827;
  long int D.28835;
  struct MonoInst * D.28836;
  int D.28837;
  int D.28838;
  struct MonoInst * D.28839;
  int D.28840;
  long unsigned int D.28850;
  long unsigned int D.28851;
  int D.28854;
  unsigned int D.28857;
  long unsigned int D.28858;
  struct MonoMethod * D.28863;
  unsigned int D.28866;
  unsigned int D.28867;
  long int D.28872;
  struct MonoInst * D.28873;
  int D.28874;
  int D.28875;
  long int D.28879;
  struct MonoInst * D.28880;
  int D.28881;
  int D.28882;
  long int D.28888;
  struct MonoInst * D.28889;
  int D.28890;
  int D.28891;
  long int D.28895;
  struct MonoInst * D.28896;
  int D.28897;
  int D.28898;
  short unsigned int D.28902;
  int D.28903;
  int D.28904;
  short unsigned int D.28905;
  long int D.28916;
  struct MonoInst * D.28917;
  int D.28918;
  int D.28919;
  long int D.28923;
  struct MonoInst * D.28924;
  int D.28925;
  int D.28926;
  long int D.28932;
  struct MonoInst * D.28933;
  int D.28934;
  int D.28935;
  long int D.28939;
  struct MonoInst * D.28940;
  int D.28941;
  int D.28942;
  int D.28946;
  short unsigned int D.28947;
  unsigned int D.28948;
  int D.28949;
  long int D.28954;
  struct MonoInst * D.28955;
  int D.28956;
  int D.28957;
  long int D.28961;
  struct MonoInst * D.28962;
  int D.28963;
  int D.28964;
  long int D.28969;
  struct MonoInst * D.28970;
  int D.28971;
  int D.28972;
  unsigned char D.28973;
  int mono_use_imt.2;
  struct MonoMethod * D.28982;
  int imt_slot.3;
  int D.28984;
  unsigned int D.28987;
  int D.28988;
  int D.28990;
  int D.28991;
  unsigned int D.28992;
  unsigned int D.28993;
  struct MonoMethodSignature * D.28996;
  short unsigned int D.28997;
  _Bool D.28998;
  long int D.28999;
  long int D.29000;
  long int D.29003;
  gboolean might_be_remote;
  gboolean virtual;
  gboolean enable_for_aot;
  int context_used;
  struct MonoCallInst * call;
  int rgctx_reg;
  gboolean need_unbox_trampoline;

  might_be_remote = 0;
  D.28721 = this != 0B;
  virtual = (gboolean) D.28721;
  enable_for_aot = 1;
  rgctx_reg = 0;
  if (sig == 0B) goto <D.28722>; else goto <D.28723>;
  <D.28722>:
  sig = mono_method_signature (method);
  <D.28723>:
  if (rgctx_arg != 0B) goto <D.28724>; else goto <D.28725>;
  <D.28724>:
  D.28726 = mono_alloc_preg (cfg);
  rgctx_reg = (int) D.28726;
  {
    struct MonoInst * inst;

    D.28727 = cfg->mempool;
    inst = mono_mempool_alloc (D.28727, 80);
    inst->data.op[1].const_val = 0;
    D.28728 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.28728;
    inst->prev = 0B;
    D.28729 = inst->prev;
    inst->next = D.28729;
    inst->opcode = 424;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.28730 = inst->sreg3;
    inst->sreg2 = D.28730;
    D.28731 = inst->sreg2;
    inst->sreg1 = D.28731;
    D.28732 = cfg->ip;
    inst->cil_code = D.28732;
    inst->dreg = rgctx_reg;
    D.28733 = rgctx_arg->dreg;
    inst->sreg1 = D.28733;
    D.28734 = cfg->cbb;
    D.28735 = D.28734->last_ins;
    if (D.28735 != 0B) goto <D.28736>; else goto <D.28737>;
    <D.28736>:
    D.28734 = cfg->cbb;
    D.28735 = D.28734->last_ins;
    D.28735->next = inst;
    D.28734 = cfg->cbb;
    D.28735 = D.28734->last_ins;
    inst->prev = D.28735;
    D.28734 = cfg->cbb;
    D.28734->last_ins = inst;
    goto <D.28738>;
    <D.28737>:
    D.28734 = cfg->cbb;
    D.28734 = cfg->cbb;
    D.28734->last_ins = inst;
    D.28735 = D.28734->last_ins;
    D.28734->code = D.28735;
    <D.28738>:
  }
  <D.28725>:
  D.28739 = BIT_FIELD_REF <*method, 64, 256>;
  D.28740 = D.28739 & 72057594037927936;
  if (D.28740 != 0) goto <D.28741>; else goto <D.28742>;
  <D.28741>:
  {
    struct MonoMethodSignature * ctor_sig;

    D.28727 = cfg->mempool;
    ctor_sig = mono_metadata_signature_dup_mempool (D.28727, sig);
    D.28743 = mono_defaults.string_class;
    D.28744 = &D.28743->byval_arg;
    ctor_sig->ret = D.28744;
    sig = ctor_sig;
  }
  <D.28742>:
  context_used = mini_method_check_context_used (cfg, method);
  if (this != 0B) goto <D.28750>; else goto <D.28746>;
  <D.28750>:
  D.28751 = BIT_FIELD_REF <*sig, 64, 64>;
  D.28752 = D.28751 & 512;
  if (D.28752 != 0) goto <D.28753>; else goto <D.28746>;
  <D.28753>:
  D.28754 = method->klass;
  D.28755 = BIT_FIELD_REF <*D.28754, 64, 256>;
  D.28756 = D.28755 & 2199023255552;
  if (D.28756 != 0) goto <D.28747>; else goto <D.28757>;
  <D.28757>:
  D.28754 = method->klass;
  D.28758 = mono_defaults.object_class;
  if (D.28754 == D.28758) goto <D.28747>; else goto <D.28746>;
  <D.28747>:
  D.28759 = method->flags;
  D.28760 = (int) D.28759;
  D.28761 = D.28760 & 64;
  if (D.28761 == 0) goto <D.28762>; else goto <D.28746>;
  <D.28762>:
  D.28763 = cfg->method;
  D.28764 = mono_method_signature (D.28763);
  D.28765 = BIT_FIELD_REF <*D.28764, 64, 64>;
  D.28766 = D.28765 & 512;
  if (D.28766 == 0) goto <D.28748>; else goto <D.28767>;
  <D.28767>:
  D.28768 = this->opcode;
  if (D.28768 != 424) goto <D.28748>; else goto <D.28769>;
  <D.28769>:
  D.28770 = this->sreg1;
  D.28771 = cfg->args;
  D.28772 = *D.28771;
  D.28773 = D.28772->dreg;
  if (D.28770 != D.28773) goto <D.28748>; else goto <D.28774>;
  <D.28774>:
  if (context_used != 0) goto <D.28748>; else goto <D.28746>;
  <D.28748>:
  iftmp.0 = 1;
  goto <D.28749>;
  <D.28746>:
  iftmp.0 = 0;
  <D.28749>:
  might_be_remote = iftmp.0;
  if (might_be_remote != 0) goto <D.28775>; else goto <D.28776>;
  <D.28775>:
  if (context_used != 0) goto <D.28777>; else goto <D.28778>;
  <D.28777>:
  {
    struct MonoInst * addr;

    D.28779 = cfg->generic_sharing_context;
    D.28780 = D.28779 == 0B;
    D.28781 = (long int) D.28780;
    D.28782 = __builtin_expect (D.28781, 0);
    if (D.28782 != 0) goto <D.28783>; else goto <D.28784>;
    <D.28783>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 2632, "cfg->generic_sharing_context");
    <D.28784>:
    addr = emit_get_rgctx_method (cfg, context_used, method, 10);
    D.28785 = mono_emit_calli (cfg, sig, args, addr, 0B, 0B);
    return D.28785;
  }
  <D.28778>:
  <D.28776>:
  D.28754 = method->klass;
  D.28758 = mono_defaults.object_class;
  if (D.28754 == D.28758) goto <D.28787>; else goto <D.28790>;
  <D.28790>:
  D.28754 = method->klass;
  D.28791 = D.28754->flags;
  D.28792 = D.28791 & 32;
  if (D.28792 != 0) goto <D.28787>; else goto <D.28788>;
  <D.28787>:
  iftmp.1 = 1;
  goto <D.28789>;
  <D.28788>:
  iftmp.1 = 0;
  <D.28789>:
  need_unbox_trampoline = iftmp.1;
  D.28793 = rgctx_arg != 0B;
  D.28794 = (int) D.28793;
  call = mono_emit_call_args (cfg, sig, args, 0, virtual, tail, D.28794, need_unbox_trampoline);
  if (might_be_remote != 0) goto <D.28795>; else goto <D.28796>;
  <D.28795>:
  D.28797 = mono_marshal_get_remoting_invoke_with_check (method);
  call->method = D.28797;
  goto <D.28798>;
  <D.28796>:
  call->method = method;
  <D.28798>:
  D.28799 = call->inst.flags;
  D.28800 = D.28799 | 1;
  call->inst.flags = D.28800;
  call->inst.data.op[0].src = this;
  D.28801 = (unsigned char) tail;
  D.28802 = (<unnamed-unsigned:1>) D.28801;
  call->tail_call = D.28802;
  if (virtual != 0) goto <D.28803>; else goto <D.28804>;
  <D.28803>:
  {
    int vtable_reg;
    int slot_reg;
    int this_reg;
    int offset;

    this_reg = this->dreg;
    D.28754 = method->klass;
    D.28805 = D.28754->parent;
    D.28806 = mono_defaults.multicastdelegate_class;
    if (D.28805 == D.28806) goto <D.28807>; else goto <D.28808>;
    <D.28807>:
    D.28809 = method->name;
    D.28810 = strcmp (D.28809, "Invoke");
    if (D.28810 == 0) goto <D.28811>; else goto <D.28812>;
    <D.28811>:
    {
      struct MonoInst * dummy_use;

      D.28813 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.28814 = D.28813 & 144115188075855872;
      if (D.28814 != 0) goto <D.28815>; else goto <D.28816>;
      <D.28815>:
      {
        struct MonoInst * inst;

        D.28727 = cfg->mempool;
        inst = mono_mempool_alloc (D.28727, 80);
        inst->data.op[1].const_val = 0;
        D.28817 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.28817;
        inst->prev = 0B;
        D.28818 = inst->prev;
        inst->next = D.28818;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.28819 = inst->sreg3;
        inst->sreg2 = D.28819;
        D.28820 = inst->sreg2;
        inst->sreg1 = D.28820;
        D.28732 = cfg->ip;
        inst->cil_code = D.28732;
        inst->dreg = -1;
        inst->sreg1 = this_reg;
        inst->data.op[1].const_val = 0;
        D.28734 = cfg->cbb;
        D.28735 = D.28734->last_ins;
        if (D.28735 != 0B) goto <D.28821>; else goto <D.28822>;
        <D.28821>:
        D.28734 = cfg->cbb;
        D.28735 = D.28734->last_ins;
        D.28735->next = inst;
        D.28734 = cfg->cbb;
        D.28735 = D.28734->last_ins;
        inst->prev = D.28735;
        D.28734 = cfg->cbb;
        D.28734->last_ins = inst;
        goto <D.28823>;
        <D.28822>:
        D.28734 = cfg->cbb;
        D.28734 = cfg->cbb;
        D.28734->last_ins = inst;
        D.28735 = D.28734->last_ins;
        D.28734->code = D.28735;
        <D.28823>:
      }
      {
        struct MonoInst * inst;

        D.28727 = cfg->mempool;
        inst = mono_mempool_alloc (D.28727, 80);
        inst->data.op[1].const_val = 0;
        D.28824 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.28824;
        inst->prev = 0B;
        D.28825 = inst->prev;
        inst->next = D.28825;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.28826 = inst->sreg3;
        inst->sreg2 = D.28826;
        D.28827 = inst->sreg2;
        inst->sreg1 = D.28827;
        D.28732 = cfg->ip;
        inst->cil_code = D.28732;
        inst->data.op[1].p = "NullReferenceException";
        D.28734 = cfg->cbb;
        D.28735 = D.28734->last_ins;
        if (D.28735 != 0B) goto <D.28828>; else goto <D.28829>;
        <D.28828>:
        D.28734 = cfg->cbb;
        D.28735 = D.28734->last_ins;
        D.28735->next = inst;
        D.28734 = cfg->cbb;
        D.28735 = D.28734->last_ins;
        inst->prev = D.28735;
        D.28734 = cfg->cbb;
        D.28734->last_ins = inst;
        goto <D.28830>;
        <D.28829>:
        D.28734 = cfg->cbb;
        D.28734 = cfg->cbb;
        D.28734->last_ins = inst;
        D.28735 = D.28734->last_ins;
        D.28734->code = D.28735;
        <D.28830>:
      }
      goto <D.28831>;
      <D.28816>:
      <D.28831>:
      call->inst.sreg1 = this_reg;
      call->inst.data.op[0].const_val = 24;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      if (D.28735 != 0B) goto <D.28832>; else goto <D.28833>;
      <D.28832>:
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      D.28735->next = call;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      MEM[(struct MonoInst *)call].prev = D.28735;
      D.28734 = cfg->cbb;
      D.28734->last_ins = call;
      goto <D.28834>;
      <D.28833>:
      D.28734 = cfg->cbb;
      D.28734 = cfg->cbb;
      D.28734->last_ins = call;
      D.28735 = D.28734->last_ins;
      D.28734->code = D.28735;
      <D.28834>:
      D.28727 = cfg->mempool;
      dummy_use = mono_mempool_alloc (D.28727, 80);
      dummy_use->data.op[1].const_val = 0;
      D.28835 = dummy_use->data.op[1].const_val;
      dummy_use->data.op[0].const_val = D.28835;
      dummy_use->prev = 0B;
      D.28836 = dummy_use->prev;
      dummy_use->next = D.28836;
      dummy_use->opcode = 796;
      dummy_use->flags = 0;
      dummy_use->type = 0;
      dummy_use->dreg = -1;
      dummy_use->sreg3 = -1;
      D.28837 = dummy_use->sreg3;
      dummy_use->sreg2 = D.28837;
      D.28838 = dummy_use->sreg2;
      dummy_use->sreg1 = D.28838;
      D.28732 = cfg->ip;
      dummy_use->cil_code = D.28732;
      D.28839 = *args;
      D.28840 = D.28839->dreg;
      dummy_use->sreg1 = D.28840;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      if (D.28735 != 0B) goto <D.28841>; else goto <D.28842>;
      <D.28841>:
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      D.28735->next = dummy_use;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      dummy_use->prev = D.28735;
      D.28734 = cfg->cbb;
      D.28734->last_ins = dummy_use;
      goto <D.28843>;
      <D.28842>:
      D.28734 = cfg->cbb;
      D.28734 = cfg->cbb;
      D.28734->last_ins = dummy_use;
      D.28735 = D.28734->last_ins;
      D.28734->code = D.28735;
      <D.28843>:
      D.28785 = call;
      return D.28785;
    }
    <D.28812>:
    <D.28808>:
    D.28850 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.28851 = D.28850 & 33554432;
    if (D.28851 == 0) goto <D.28844>; else goto <D.28852>;
    <D.28852>:
    if (enable_for_aot != 0) goto <D.28844>; else goto <D.28845>;
    <D.28844>:
    D.28759 = method->flags;
    D.28760 = (int) D.28759;
    D.28761 = D.28760 & 64;
    if (D.28761 == 0) goto <D.28846>; else goto <D.28853>;
    <D.28853>:
    D.28759 = method->flags;
    D.28760 = (int) D.28759;
    D.28854 = D.28760 & 32;
    if (D.28854 != 0) goto <D.28847>; else goto <D.28855>;
    <D.28855>:
    D.28754 = method->klass;
    if (D.28754 != 0B) goto <D.28856>; else goto <D.28845>;
    <D.28856>:
    D.28754 = method->klass;
    D.28791 = D.28754->flags;
    D.28857 = D.28791 & 256;
    if (D.28857 != 0) goto <D.28847>; else goto <D.28845>;
    <D.28847>:
    D.28739 = BIT_FIELD_REF <*method, 64, 256>;
    D.28858 = D.28739 & 4467570830351532032;
    if (D.28858 != 1297036692682702848) goto <D.28846>; else goto <D.28845>;
    <D.28846>:
    D.28754 = method->klass;
    D.28755 = BIT_FIELD_REF <*D.28754, 64, 256>;
    D.28756 = D.28755 & 2199023255552;
    if (D.28756 == 0) goto <D.28848>; else goto <D.28859>;
    <D.28859>:
    if (context_used == 0) goto <D.28848>; else goto <D.28845>;
    <D.28848>:
    D.28754 = method->klass;
    D.28755 = BIT_FIELD_REF <*D.28754, 64, 256>;
    D.28756 = D.28755 & 2199023255552;
    if (D.28756 != 0) goto <D.28860>; else goto <D.28862>;
    <D.28862>:
    D.28754 = method->klass;
    D.28758 = mono_defaults.object_class;
    if (D.28754 == D.28758) goto <D.28860>; else goto <D.28861>;
    <D.28860>:
    D.28863 = mono_marshal_get_remoting_invoke_with_check (method);
    call->method = D.28863;
    method = call->method;
    <D.28861>:
    D.28739 = BIT_FIELD_REF <*method, 64, 256>;
    D.28740 = D.28739 & 72057594037927936;
    if (D.28740 == 0) goto <D.28864>; else goto <D.28865>;
    <D.28864>:
    D.28866 = cfg->flags;
    D.28867 = D.28866 | 128;
    cfg->flags = D.28867;
    D.28813 = BIT_FIELD_REF <*cfg, 64, 5632>;
    D.28814 = D.28813 & 144115188075855872;
    if (D.28814 != 0) goto <D.28868>; else goto <D.28869>;
    <D.28868>:
    D.28813 = BIT_FIELD_REF <*cfg, 64, 5632>;
    D.28814 = D.28813 & 144115188075855872;
    if (D.28814 != 0) goto <D.28870>; else goto <D.28871>;
    <D.28870>:
    {
      struct MonoInst * inst;

      D.28727 = cfg->mempool;
      inst = mono_mempool_alloc (D.28727, 80);
      inst->data.op[1].const_val = 0;
      D.28872 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28872;
      inst->prev = 0B;
      D.28873 = inst->prev;
      inst->next = D.28873;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28874 = inst->sreg3;
      inst->sreg2 = D.28874;
      D.28875 = inst->sreg2;
      inst->sreg1 = D.28875;
      D.28732 = cfg->ip;
      inst->cil_code = D.28732;
      inst->dreg = -1;
      inst->sreg1 = this_reg;
      inst->data.op[1].const_val = 0;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      if (D.28735 != 0B) goto <D.28876>; else goto <D.28877>;
      <D.28876>:
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      D.28735->next = inst;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      inst->prev = D.28735;
      D.28734 = cfg->cbb;
      D.28734->last_ins = inst;
      goto <D.28878>;
      <D.28877>:
      D.28734 = cfg->cbb;
      D.28734 = cfg->cbb;
      D.28734->last_ins = inst;
      D.28735 = D.28734->last_ins;
      D.28734->code = D.28735;
      <D.28878>:
    }
    {
      struct MonoInst * inst;

      D.28727 = cfg->mempool;
      inst = mono_mempool_alloc (D.28727, 80);
      inst->data.op[1].const_val = 0;
      D.28879 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28879;
      inst->prev = 0B;
      D.28880 = inst->prev;
      inst->next = D.28880;
      inst->opcode = 451;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28881 = inst->sreg3;
      inst->sreg2 = D.28881;
      D.28882 = inst->sreg2;
      inst->sreg1 = D.28882;
      D.28732 = cfg->ip;
      inst->cil_code = D.28732;
      inst->data.op[1].p = "NullReferenceException";
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      if (D.28735 != 0B) goto <D.28883>; else goto <D.28884>;
      <D.28883>:
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      D.28735->next = inst;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      inst->prev = D.28735;
      D.28734 = cfg->cbb;
      D.28734->last_ins = inst;
      goto <D.28885>;
      <D.28884>:
      D.28734 = cfg->cbb;
      D.28734 = cfg->cbb;
      D.28734->last_ins = inst;
      D.28735 = D.28734->last_ins;
      D.28734->code = D.28735;
      <D.28885>:
    }
    goto <D.28886>;
    <D.28871>:
    <D.28886>:
    goto <D.28887>;
    <D.28869>:
    {
      struct MonoInst * inst;

      D.28727 = cfg->mempool;
      inst = mono_mempool_alloc (D.28727, 80);
      inst->data.op[1].const_val = 0;
      D.28888 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28888;
      inst->prev = 0B;
      D.28889 = inst->prev;
      inst->next = D.28889;
      inst->opcode = 340;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28890 = inst->sreg3;
      inst->sreg2 = D.28890;
      D.28891 = inst->sreg2;
      inst->sreg1 = D.28891;
      D.28732 = cfg->ip;
      inst->cil_code = D.28732;
      inst->dreg = -1;
      inst->sreg1 = this_reg;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      if (D.28735 != 0B) goto <D.28892>; else goto <D.28893>;
      <D.28892>:
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      D.28735->next = inst;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      inst->prev = D.28735;
      D.28734 = cfg->cbb;
      D.28734->last_ins = inst;
      goto <D.28894>;
      <D.28893>:
      D.28734 = cfg->cbb;
      D.28734 = cfg->cbb;
      D.28734->last_ins = inst;
      D.28735 = D.28734->last_ins;
      D.28734->code = D.28735;
      <D.28894>:
    }
    <D.28887>:
    {
      struct MonoInst * inst;

      D.28727 = cfg->mempool;
      inst = mono_mempool_alloc (D.28727, 80);
      inst->data.op[1].const_val = 0;
      D.28895 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28895;
      inst->prev = 0B;
      D.28896 = inst->prev;
      inst->next = D.28896;
      inst->opcode = 799;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28897 = inst->sreg3;
      inst->sreg2 = D.28897;
      D.28898 = inst->sreg2;
      inst->sreg1 = D.28898;
      D.28732 = cfg->ip;
      inst->cil_code = D.28732;
      inst->dreg = -1;
      inst->sreg1 = this_reg;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      if (D.28735 != 0B) goto <D.28899>; else goto <D.28900>;
      <D.28899>:
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      D.28735->next = inst;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      inst->prev = D.28735;
      D.28734 = cfg->cbb;
      D.28734->last_ins = inst;
      goto <D.28901>;
      <D.28900>:
      D.28734 = cfg->cbb;
      D.28734 = cfg->cbb;
      D.28734->last_ins = inst;
      D.28735 = D.28734->last_ins;
      D.28734->code = D.28735;
      <D.28901>:
    }
    <D.28865>:
    D.28902 = call->inst.opcode;
    D.28903 = (int) D.28902;
    D.28904 = callvirt_to_call (D.28903);
    D.28905 = (short unsigned int) D.28904;
    call->inst.opcode = D.28905;
    goto <D.28849>;
    <D.28845>:
    D.28759 = method->flags;
    D.28760 = (int) D.28759;
    D.28761 = D.28760 & 64;
    if (D.28761 != 0) goto <D.28909>; else goto <D.28906>;
    <D.28909>:
    D.28759 = method->flags;
    D.28760 = (int) D.28759;
    D.28854 = D.28760 & 32;
    if (D.28854 != 0) goto <D.28907>; else goto <D.28910>;
    <D.28910>:
    D.28754 = method->klass;
    if (D.28754 != 0B) goto <D.28911>; else goto <D.28906>;
    <D.28911>:
    D.28754 = method->klass;
    D.28791 = D.28754->flags;
    D.28857 = D.28791 & 256;
    if (D.28857 != 0) goto <D.28907>; else goto <D.28906>;
    <D.28907>:
    D.28866 = cfg->flags;
    D.28867 = D.28866 | 128;
    cfg->flags = D.28867;
    D.28813 = BIT_FIELD_REF <*cfg, 64, 5632>;
    D.28814 = D.28813 & 144115188075855872;
    if (D.28814 != 0) goto <D.28912>; else goto <D.28913>;
    <D.28912>:
    D.28813 = BIT_FIELD_REF <*cfg, 64, 5632>;
    D.28814 = D.28813 & 144115188075855872;
    if (D.28814 != 0) goto <D.28914>; else goto <D.28915>;
    <D.28914>:
    {
      struct MonoInst * inst;

      D.28727 = cfg->mempool;
      inst = mono_mempool_alloc (D.28727, 80);
      inst->data.op[1].const_val = 0;
      D.28916 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28916;
      inst->prev = 0B;
      D.28917 = inst->prev;
      inst->next = D.28917;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28918 = inst->sreg3;
      inst->sreg2 = D.28918;
      D.28919 = inst->sreg2;
      inst->sreg1 = D.28919;
      D.28732 = cfg->ip;
      inst->cil_code = D.28732;
      inst->dreg = -1;
      inst->sreg1 = this_reg;
      inst->data.op[1].const_val = 0;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      if (D.28735 != 0B) goto <D.28920>; else goto <D.28921>;
      <D.28920>:
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      D.28735->next = inst;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      inst->prev = D.28735;
      D.28734 = cfg->cbb;
      D.28734->last_ins = inst;
      goto <D.28922>;
      <D.28921>:
      D.28734 = cfg->cbb;
      D.28734 = cfg->cbb;
      D.28734->last_ins = inst;
      D.28735 = D.28734->last_ins;
      D.28734->code = D.28735;
      <D.28922>:
    }
    {
      struct MonoInst * inst;

      D.28727 = cfg->mempool;
      inst = mono_mempool_alloc (D.28727, 80);
      inst->data.op[1].const_val = 0;
      D.28923 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28923;
      inst->prev = 0B;
      D.28924 = inst->prev;
      inst->next = D.28924;
      inst->opcode = 451;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28925 = inst->sreg3;
      inst->sreg2 = D.28925;
      D.28926 = inst->sreg2;
      inst->sreg1 = D.28926;
      D.28732 = cfg->ip;
      inst->cil_code = D.28732;
      inst->data.op[1].p = "NullReferenceException";
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      if (D.28735 != 0B) goto <D.28927>; else goto <D.28928>;
      <D.28927>:
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      D.28735->next = inst;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      inst->prev = D.28735;
      D.28734 = cfg->cbb;
      D.28734->last_ins = inst;
      goto <D.28929>;
      <D.28928>:
      D.28734 = cfg->cbb;
      D.28734 = cfg->cbb;
      D.28734->last_ins = inst;
      D.28735 = D.28734->last_ins;
      D.28734->code = D.28735;
      <D.28929>:
    }
    goto <D.28930>;
    <D.28915>:
    <D.28930>:
    goto <D.28931>;
    <D.28913>:
    {
      struct MonoInst * inst;

      D.28727 = cfg->mempool;
      inst = mono_mempool_alloc (D.28727, 80);
      inst->data.op[1].const_val = 0;
      D.28932 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28932;
      inst->prev = 0B;
      D.28933 = inst->prev;
      inst->next = D.28933;
      inst->opcode = 340;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28934 = inst->sreg3;
      inst->sreg2 = D.28934;
      D.28935 = inst->sreg2;
      inst->sreg1 = D.28935;
      D.28732 = cfg->ip;
      inst->cil_code = D.28732;
      inst->dreg = -1;
      inst->sreg1 = this_reg;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      if (D.28735 != 0B) goto <D.28936>; else goto <D.28937>;
      <D.28936>:
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      D.28735->next = inst;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      inst->prev = D.28735;
      D.28734 = cfg->cbb;
      D.28734->last_ins = inst;
      goto <D.28938>;
      <D.28937>:
      D.28734 = cfg->cbb;
      D.28734 = cfg->cbb;
      D.28734->last_ins = inst;
      D.28735 = D.28734->last_ins;
      D.28734->code = D.28735;
      <D.28938>:
    }
    <D.28931>:
    {
      struct MonoInst * inst;

      D.28727 = cfg->mempool;
      inst = mono_mempool_alloc (D.28727, 80);
      inst->data.op[1].const_val = 0;
      D.28939 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28939;
      inst->prev = 0B;
      D.28940 = inst->prev;
      inst->next = D.28940;
      inst->opcode = 799;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28941 = inst->sreg3;
      inst->sreg2 = D.28941;
      D.28942 = inst->sreg2;
      inst->sreg1 = D.28942;
      D.28732 = cfg->ip;
      inst->cil_code = D.28732;
      inst->dreg = -1;
      inst->sreg1 = this_reg;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      if (D.28735 != 0B) goto <D.28943>; else goto <D.28944>;
      <D.28943>:
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      D.28735->next = inst;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      inst->prev = D.28735;
      D.28734 = cfg->cbb;
      D.28734->last_ins = inst;
      goto <D.28945>;
      <D.28944>:
      D.28734 = cfg->cbb;
      D.28734 = cfg->cbb;
      D.28734->last_ins = inst;
      D.28735 = D.28734->last_ins;
      D.28734->code = D.28735;
      <D.28945>:
    }
    D.28902 = call->inst.opcode;
    D.28903 = (int) D.28902;
    D.28946 = callvirt_to_call (D.28903);
    D.28947 = (short unsigned int) D.28946;
    call->inst.opcode = D.28947;
    goto <D.28908>;
    <D.28906>:
    D.28948 = alloc_preg (cfg);
    vtable_reg = (int) D.28948;
    {
      struct MonoInst * inst;
      int __ins_flags;

      __ins_flags = 32;
      D.28949 = __ins_flags & 32;
      if (D.28949 != 0) goto <D.28950>; else goto <D.28951>;
      <D.28950>:
      D.28813 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.28814 = D.28813 & 144115188075855872;
      if (D.28814 != 0) goto <D.28952>; else goto <D.28953>;
      <D.28952>:
      {
        struct MonoInst * inst;

        D.28727 = cfg->mempool;
        inst = mono_mempool_alloc (D.28727, 80);
        inst->data.op[1].const_val = 0;
        D.28954 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.28954;
        inst->prev = 0B;
        D.28955 = inst->prev;
        inst->next = D.28955;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.28956 = inst->sreg3;
        inst->sreg2 = D.28956;
        D.28957 = inst->sreg2;
        inst->sreg1 = D.28957;
        D.28732 = cfg->ip;
        inst->cil_code = D.28732;
        inst->dreg = -1;
        inst->sreg1 = this_reg;
        inst->data.op[1].const_val = 0;
        D.28734 = cfg->cbb;
        D.28735 = D.28734->last_ins;
        if (D.28735 != 0B) goto <D.28958>; else goto <D.28959>;
        <D.28958>:
        D.28734 = cfg->cbb;
        D.28735 = D.28734->last_ins;
        D.28735->next = inst;
        D.28734 = cfg->cbb;
        D.28735 = D.28734->last_ins;
        inst->prev = D.28735;
        D.28734 = cfg->cbb;
        D.28734->last_ins = inst;
        goto <D.28960>;
        <D.28959>:
        D.28734 = cfg->cbb;
        D.28734 = cfg->cbb;
        D.28734->last_ins = inst;
        D.28735 = D.28734->last_ins;
        D.28734->code = D.28735;
        <D.28960>:
      }
      {
        struct MonoInst * inst;

        D.28727 = cfg->mempool;
        inst = mono_mempool_alloc (D.28727, 80);
        inst->data.op[1].const_val = 0;
        D.28961 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.28961;
        inst->prev = 0B;
        D.28962 = inst->prev;
        inst->next = D.28962;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.28963 = inst->sreg3;
        inst->sreg2 = D.28963;
        D.28964 = inst->sreg2;
        inst->sreg1 = D.28964;
        D.28732 = cfg->ip;
        inst->cil_code = D.28732;
        inst->data.op[1].p = "NullReferenceException";
        D.28734 = cfg->cbb;
        D.28735 = D.28734->last_ins;
        if (D.28735 != 0B) goto <D.28965>; else goto <D.28966>;
        <D.28965>:
        D.28734 = cfg->cbb;
        D.28735 = D.28734->last_ins;
        D.28735->next = inst;
        D.28734 = cfg->cbb;
        D.28735 = D.28734->last_ins;
        inst->prev = D.28735;
        D.28734 = cfg->cbb;
        D.28734->last_ins = inst;
        goto <D.28967>;
        <D.28966>:
        D.28734 = cfg->cbb;
        D.28734 = cfg->cbb;
        D.28734->last_ins = inst;
        D.28735 = D.28734->last_ins;
        D.28734->code = D.28735;
        <D.28967>:
      }
      goto <D.28968>;
      <D.28953>:
      <D.28968>:
      <D.28951>:
      D.28727 = cfg->mempool;
      inst = mono_mempool_alloc (D.28727, 80);
      inst->data.op[1].const_val = 0;
      D.28969 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.28969;
      inst->prev = 0B;
      D.28970 = inst->prev;
      inst->next = D.28970;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.28971 = inst->sreg3;
      inst->sreg2 = D.28971;
      D.28972 = inst->sreg2;
      inst->sreg1 = D.28972;
      D.28732 = cfg->ip;
      inst->cil_code = D.28732;
      inst->dreg = vtable_reg;
      inst->sreg1 = this_reg;
      inst->data.op[0].const_val = 0;
      inst->type = 1;
      D.28973 = (unsigned char) __ins_flags;
      inst->flags = D.28973;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      if (D.28735 != 0B) goto <D.28974>; else goto <D.28975>;
      <D.28974>:
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      D.28735->next = inst;
      D.28734 = cfg->cbb;
      D.28735 = D.28734->last_ins;
      inst->prev = D.28735;
      D.28734 = cfg->cbb;
      D.28734->last_ins = inst;
      goto <D.28976>;
      <D.28975>:
      D.28734 = cfg->cbb;
      D.28734 = cfg->cbb;
      D.28734->last_ins = inst;
      D.28735 = D.28734->last_ins;
      D.28734->code = D.28735;
      <D.28976>:
    }
    D.28754 = method->klass;
    D.28791 = D.28754->flags;
    D.28792 = D.28791 & 32;
    if (D.28792 != 0) goto <D.28977>; else goto <D.28978>;
    <D.28977>:
    slot_reg = -1;
    mono_use_imt.2 = mono_use_imt;
    if (mono_use_imt.2 != 0) goto <D.28980>; else goto <D.28981>;
    <D.28980>:
    {
      guint32 imt_slot;

      imt_slot = mono_method_get_imt_slot (method);
      D.28982 = call->method;
      emit_imt_argument (cfg, call, D.28982, imt_arg);
      slot_reg = vtable_reg;
      imt_slot.3 = (int) imt_slot;
      D.28984 = imt_slot.3 + -19;
      offset = D.28984 * 8;
    }
    <D.28981>:
    if (slot_reg == -1) goto <D.28985>; else goto <D.28986>;
    <D.28985>:
    D.28987 = alloc_preg (cfg);
    slot_reg = (int) D.28987;
    D.28754 = method->klass;
    mini_emit_load_intf_reg_vtable (cfg, slot_reg, vtable_reg, D.28754);
    D.28988 = mono_method_get_vtable_index (method);
    offset = D.28988 * 8;
    <D.28986>:
    goto <D.28989>;
    <D.28978>:
    slot_reg = vtable_reg;
    D.28990 = mono_method_get_vtable_index (method);
    D.28991 = D.28990 * 8;
    D.28992 = (unsigned int) D.28991;
    D.28993 = D.28992 + 56;
    offset = (int) D.28993;
    if (imt_arg != 0B) goto <D.28994>; else goto <D.28995>;
    <D.28994>:
    D.28996 = mono_method_signature (method);
    D.28997 = D.28996->generic_param_count;
    D.28998 = D.28997 == 0;
    D.28999 = (long int) D.28998;
    D.29000 = __builtin_expect (D.28999, 0);
    if (D.29000 != 0) goto <D.29001>; else goto <D.29002>;
    <D.29001>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 2743, "mono_method_signature (method)->generic_param_count");
    <D.29002>:
    D.28982 = call->method;
    emit_imt_argument (cfg, call, D.28982, imt_arg);
    <D.28995>:
    <D.28989>:
    call->inst.sreg1 = slot_reg;
    D.29003 = (long int) offset;
    call->inst.data.op[0].const_val = D.29003;
    call->virtual = 1;
    <D.28908>:
    <D.28849>:
  }
  <D.28804>:
  D.28734 = cfg->cbb;
  D.28735 = D.28734->last_ins;
  if (D.28735 != 0B) goto <D.29004>; else goto <D.29005>;
  <D.29004>:
  D.28734 = cfg->cbb;
  D.28735 = D.28734->last_ins;
  D.28735->next = call;
  D.28734 = cfg->cbb;
  D.28735 = D.28734->last_ins;
  MEM[(struct MonoInst *)call].prev = D.28735;
  D.28734 = cfg->cbb;
  D.28734->last_ins = call;
  goto <D.29006>;
  <D.29005>:
  D.28734 = cfg->cbb;
  D.28734 = cfg->cbb;
  D.28734->last_ins = call;
  D.28735 = D.28734->last_ins;
  D.28734->code = D.28735;
  <D.29006>:
  if (rgctx_arg != 0B) goto <D.29007>; else goto <D.29008>;
  <D.29007>:
  set_rgctx_arg (cfg, call, rgctx_reg, rgctx_arg);
  <D.29008>:
  D.28785 = call;
  return D.28785;
}


mini_method_check_context_used (struct MonoCompile * cfg, struct MonoMethod * method)
{
  struct MonoGenericSharingContext * D.29010;
  int D.29013;

  D.29010 = cfg->generic_sharing_context;
  if (D.29010 != 0B) goto <D.29011>; else goto <D.29012>;
  <D.29011>:
  D.29013 = mono_method_check_context_used (method);
  return D.29013;
  <D.29012>:
  D.29013 = 0;
  return D.29013;
}


emit_get_rgctx_method (struct MonoCompile * cfg, int context_used, struct MonoMethod * cmethod, MonoRgctxInfoType rgctx_type)
{
  struct MonoMemPool * D.29017;
  long int D.29018;
  struct MonoInst * D.29019;
  guint16 iftmp.4;
  long unsigned int D.29021;
  long unsigned int D.29022;
  int D.29026;
  int D.29027;
  const unsigned char * D.29028;
  unsigned int D.29029;
  int D.29030;
  struct MonoBasicBlock * D.29031;
  struct MonoInst * D.29032;
  struct MonoInst * D.29036;
  guint16 iftmp.5;
  unsigned int D.29043;
  int D.29044;
  struct MonoDomain * D.29046;
  struct MonoClass * D.29047;
  struct MonoVTable * D.29048;
  struct MonoGenericContext * D.29049;
  struct MonoGenericInst * D.29050;
  unsigned int D.29051;
  int D.29052;
  struct MonoMethod * D.29056;
  int D.29057;

  if (context_used == 0) goto <D.29015>; else goto <D.29016>;
  <D.29015>:
  {
    struct MonoInst * ins;

    switch (rgctx_type) <default: <D.26176>, case 5: <D.26173>, case 8: <D.26174>>
    <D.26173>:
    D.29017 = cfg->mempool;
    ins = mono_mempool_alloc (D.29017, 80);
    ins->data.op[1].const_val = 0;
    D.29018 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.29018;
    ins->prev = 0B;
    D.29019 = ins->prev;
    ins->next = D.29019;
    D.29021 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.29022 = D.29021 & 33554432;
    if (D.29022 != 0) goto <D.29023>; else goto <D.29024>;
    <D.29023>:
    iftmp.4 = 732;
    goto <D.29025>;
    <D.29024>:
    iftmp.4 = 363;
    <D.29025>:
    ins->opcode = iftmp.4;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.29026 = ins->sreg3;
    ins->sreg2 = D.29026;
    D.29027 = ins->sreg2;
    ins->sreg1 = D.29027;
    D.29028 = cfg->ip;
    ins->cil_code = D.29028;
    ins->data.op[0].p = cmethod;
    ins->data.op[1].src = 6B;
    ins->type = 3;
    D.29029 = alloc_dreg (cfg, 3);
    D.29030 = (int) D.29029;
    ins->dreg = D.29030;
    D.29031 = cfg->cbb;
    D.29032 = D.29031->last_ins;
    if (D.29032 != 0B) goto <D.29033>; else goto <D.29034>;
    <D.29033>:
    D.29031 = cfg->cbb;
    D.29032 = D.29031->last_ins;
    D.29032->next = ins;
    D.29031 = cfg->cbb;
    D.29032 = D.29031->last_ins;
    ins->prev = D.29032;
    D.29031 = cfg->cbb;
    D.29031->last_ins = ins;
    goto <D.29035>;
    <D.29034>:
    D.29031 = cfg->cbb;
    D.29031 = cfg->cbb;
    D.29031->last_ins = ins;
    D.29032 = D.29031->last_ins;
    D.29031->code = D.29032;
    <D.29035>:
    D.29036 = ins;
    return D.29036;
    <D.26174>:
    D.29021 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.29022 = D.29021 & 33554432;
    if (D.29022 != 0) goto <D.29037>; else goto <D.29038>;
    <D.29037>:
    D.29017 = cfg->mempool;
    ins = mono_mempool_alloc (D.29017, 80);
    ins->data.op[1].const_val = 0;
    D.29018 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.29018;
    ins->prev = 0B;
    D.29019 = ins->prev;
    ins->next = D.29019;
    D.29021 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.29022 = D.29021 & 33554432;
    if (D.29022 != 0) goto <D.29040>; else goto <D.29041>;
    <D.29040>:
    iftmp.5 = 732;
    goto <D.29042>;
    <D.29041>:
    iftmp.5 = 363;
    <D.29042>:
    ins->opcode = iftmp.5;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.29026 = ins->sreg3;
    ins->sreg2 = D.29026;
    D.29027 = ins->sreg2;
    ins->sreg1 = D.29027;
    D.29028 = cfg->ip;
    ins->cil_code = D.29028;
    ins->data.op[0].p = cmethod;
    ins->data.op[1].src = 34B;
    ins->type = 3;
    D.29043 = alloc_dreg (cfg, 3);
    D.29044 = (int) D.29043;
    ins->dreg = D.29044;
    goto <D.29045>;
    <D.29038>:
    {
      struct MonoMethodRuntimeGenericContext * mrgctx;

      D.29046 = cfg->domain;
      D.29047 = cmethod->klass;
      D.29048 = mono_class_vtable (D.29046, D.29047);
      D.29049 = mini_method_get_context (cmethod);
      D.29050 = D.29049->method_inst;
      mrgctx = mono_method_lookup_rgctx (D.29048, D.29050);
      D.29017 = cfg->mempool;
      ins = mono_mempool_alloc (D.29017, 80);
      ins->data.op[1].const_val = 0;
      D.29018 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.29018;
      ins->prev = 0B;
      D.29019 = ins->prev;
      ins->next = D.29019;
      ins->opcode = 363;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.29026 = ins->sreg3;
      ins->sreg2 = D.29026;
      D.29027 = ins->sreg2;
      ins->sreg1 = D.29027;
      D.29028 = cfg->ip;
      ins->cil_code = D.29028;
      ins->data.op[0].p = mrgctx;
      ins->type = 3;
      D.29051 = alloc_dreg (cfg, 3);
      D.29052 = (int) D.29051;
      ins->dreg = D.29052;
    }
    <D.29045>:
    D.29031 = cfg->cbb;
    D.29032 = D.29031->last_ins;
    if (D.29032 != 0B) goto <D.29053>; else goto <D.29054>;
    <D.29053>:
    D.29031 = cfg->cbb;
    D.29032 = D.29031->last_ins;
    D.29032->next = ins;
    D.29031 = cfg->cbb;
    D.29032 = D.29031->last_ins;
    ins->prev = D.29032;
    D.29031 = cfg->cbb;
    D.29031->last_ins = ins;
    goto <D.29055>;
    <D.29054>:
    D.29031 = cfg->cbb;
    D.29031 = cfg->cbb;
    D.29031->last_ins = ins;
    D.29032 = D.29031->last_ins;
    D.29031->code = D.29032;
    <D.29055>:
    D.29036 = ins;
    return D.29036;
    <D.26176>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 3327);
  }
  <D.29016>:
  {
    struct MonoJumpInfoRgctxEntry * entry;
    struct MonoInst * rgctx;

    D.29017 = cfg->mempool;
    D.29056 = cfg->current_method;
    D.29057 = context_used & 2;
    entry = mono_patch_info_rgctx_entry_new (D.29017, D.29056, D.29057, 6, cmethod, rgctx_type);
    D.29056 = cfg->current_method;
    rgctx = emit_get_rgctx (cfg, D.29056, context_used);
    D.29036 = emit_rgctx_fetch (cfg, rgctx, entry);
    return D.29036;
  }
}


mono_patch_info_rgctx_entry_new (struct MonoMemPool * mp, struct MonoMethod * method, gboolean in_mrgctx, MonoJumpInfoType patch_type, const void * patch_data, MonoRgctxInfoType info_type)
{
  void * D.29059;
  struct MonoJumpInfo * D.29060;
  struct MonoJumpInfoRgctxEntry * D.29061;
  struct MonoJumpInfoRgctxEntry * res;

  res = mono_mempool_alloc0 (mp, 32);
  res->method = method;
  res->in_mrgctx = in_mrgctx;
  D.29059 = mono_mempool_alloc0 (mp, 40);
  res->data = D.29059;
  D.29060 = res->data;
  D.29060->type = patch_type;
  D.29060 = res->data;
  D.29060->data.target = patch_data;
  res->info_type = info_type;
  D.29061 = res;
  return D.29061;
}


emit_get_rgctx (struct MonoCompile * cfg, struct MonoMethod * method, int context_used)
{
  struct MonoGenericSharingContext * D.29063;
  _Bool D.29064;
  long int D.29065;
  long int D.29066;
  short unsigned int D.29069;
  int D.29070;
  int D.29071;
  int D.29074;
  struct MonoClass * D.29077;
  long unsigned int D.29078;
  long unsigned int D.29079;
  struct MonoMemPool * D.29082;
  long int D.29083;
  struct MonoInst * D.29084;
  int D.29085;
  int D.29086;
  const unsigned char * D.29087;
  struct MonoType * * D.29088;
  struct MonoType * D.29089;
  unsigned int D.29090;
  short unsigned int D.29091;
  struct MonoInst * * D.29092;
  struct MonoInst * D.29093;
  struct MonoClass * D.29094;
  int D.29095;
  unsigned char D.29096;
  <unnamed type> D.29097;
  unsigned int D.29098;
  int D.29099;
  short unsigned int D.29100;
  struct MonoClass * D.29103;
  struct MonoBasicBlock * D.29104;
  struct MonoInst * D.29105;
  _Bool D.29111;
  long int D.29112;
  long int D.29113;
  int iftmp.6;
  long unsigned int D.29120;
  long unsigned int D.29121;
  struct MonoGenericContext * D.29123;
  struct MonoGenericInst * D.29124;
  _Bool D.29125;
  long int D.29126;
  long int D.29127;
  long int D.29130;
  struct MonoInst * D.29131;
  int D.29132;
  int D.29133;
  struct MonoInst * * D.29134;
  long int D.29135;
  long unsigned int D.29136;
  long unsigned int D.29137;
  struct MonoInst * * D.29138;
  struct MonoInst * D.29139;
  struct MonoType * D.29140;
  unsigned int D.29141;
  short unsigned int D.29142;
  struct MonoClass * D.29143;
  int D.29144;
  unsigned char D.29145;
  <unnamed type> D.29146;
  unsigned int D.29147;
  int D.29148;
  short unsigned int D.29149;
  struct MonoClass * D.29152;
  struct MonoInst * D.29156;
  long int D.29162;
  struct MonoInst * D.29163;
  int D.29164;
  int D.29165;
  long int D.29166;
  long unsigned int D.29167;
  long unsigned int D.29168;
  struct MonoInst * * D.29169;
  struct MonoInst * D.29170;
  struct MonoType * D.29171;
  unsigned int D.29172;
  short unsigned int D.29173;
  struct MonoClass * D.29174;
  int D.29175;
  unsigned char D.29176;
  <unnamed type> D.29177;
  unsigned int D.29178;
  int D.29179;
  short unsigned int D.29180;
  struct MonoClass * D.29183;
  struct MonoGenericContext * D.29189;
  struct MonoGenericInst * D.29190;
  unsigned int D.29193;
  int D.29194;
  unsigned int D.29198;
  long int D.29199;
  struct MonoInst * D.29200;
  int D.29201;
  int D.29202;
  int D.29203;
  struct MonoInst * this;

  this = 0B;
  D.29063 = cfg->generic_sharing_context;
  D.29064 = D.29063 == 0B;
  D.29065 = (long int) D.29064;
  D.29066 = __builtin_expect (D.29065, 0);
  if (D.29066 != 0) goto <D.29067>; else goto <D.29068>;
  <D.29067>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3189, "cfg->generic_sharing_context");
  <D.29068>:
  D.29069 = method->flags;
  D.29070 = (int) D.29069;
  D.29071 = D.29070 & 16;
  if (D.29071 == 0) goto <D.29072>; else goto <D.29073>;
  <D.29072>:
  D.29074 = context_used & 2;
  if (D.29074 == 0) goto <D.29075>; else goto <D.29076>;
  <D.29075>:
  D.29077 = method->klass;
  D.29078 = BIT_FIELD_REF <*D.29077, 64, 256>;
  D.29079 = D.29078 & 1152921504606846976;
  if (D.29079 == 0) goto <D.29080>; else goto <D.29081>;
  <D.29080>:
  D.29082 = cfg->mempool;
  this = mono_mempool_alloc (D.29082, 80);
  this->data.op[1].const_val = 0;
  D.29083 = this->data.op[1].const_val;
  this->data.op[0].const_val = D.29083;
  this->prev = 0B;
  D.29084 = this->prev;
  this->next = D.29084;
  this->opcode = 424;
  this->flags = 0;
  this->type = 0;
  this->dreg = -1;
  this->sreg3 = -1;
  D.29085 = this->sreg3;
  this->sreg2 = D.29085;
  D.29086 = this->sreg2;
  this->sreg1 = D.29086;
  D.29087 = cfg->ip;
  this->cil_code = D.29087;
  D.29088 = cfg->arg_types;
  D.29089 = *D.29088;
  D.29090 = mono_type_to_regmove (cfg, D.29089);
  D.29091 = (short unsigned int) D.29090;
  this->opcode = D.29091;
  D.29088 = cfg->arg_types;
  D.29089 = *D.29088;
  type_to_eval_stack_type (cfg, D.29089, this);
  D.29092 = cfg->args;
  D.29093 = *D.29092;
  D.29094 = D.29093->klass;
  this->klass = D.29094;
  D.29092 = cfg->args;
  D.29093 = *D.29092;
  D.29095 = D.29093->dreg;
  this->sreg1 = D.29095;
  D.29096 = this->type;
  D.29097 = (<unnamed type>) D.29096;
  D.29098 = alloc_dreg (cfg, D.29097);
  D.29099 = (int) D.29098;
  this->dreg = D.29099;
  D.29100 = this->opcode;
  if (D.29100 == 427) goto <D.29101>; else goto <D.29102>;
  <D.29101>:
  D.29088 = cfg->arg_types;
  D.29089 = *D.29088;
  D.29103 = mono_class_from_mono_type (D.29089);
  this->klass = D.29103;
  <D.29102>:
  D.29104 = cfg->cbb;
  D.29105 = D.29104->last_ins;
  if (D.29105 != 0B) goto <D.29106>; else goto <D.29107>;
  <D.29106>:
  D.29104 = cfg->cbb;
  D.29105 = D.29104->last_ins;
  D.29105->next = this;
  D.29104 = cfg->cbb;
  D.29105 = D.29104->last_ins;
  this->prev = D.29105;
  D.29104 = cfg->cbb;
  D.29104->last_ins = this;
  goto <D.29108>;
  <D.29107>:
  D.29104 = cfg->cbb;
  D.29104 = cfg->cbb;
  D.29104->last_ins = this;
  D.29105 = D.29104->last_ins;
  D.29104->code = D.29105;
  <D.29108>:
  <D.29081>:
  <D.29076>:
  <D.29073>:
  D.29074 = context_used & 2;
  if (D.29074 != 0) goto <D.29109>; else goto <D.29110>;
  <D.29109>:
  {
    struct MonoInst * mrgctx_loc;
    struct MonoInst * mrgctx_var;

    D.29111 = this != 0B;
    D.29112 = (long int) D.29111;
    D.29113 = __builtin_expect (D.29112, 0);
    if (D.29113 != 0) goto <D.29114>; else goto <D.29115>;
    <D.29114>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3199, "!this");
    <D.29115>:
    D.29120 = BIT_FIELD_REF <*method, 64, 256>;
    D.29121 = D.29120 & 2251799813685248;
    if (D.29121 == 0) goto <D.29117>; else goto <D.29122>;
    <D.29122>:
    D.29123 = mono_method_get_context (method);
    D.29124 = D.29123->method_inst;
    if (D.29124 == 0B) goto <D.29117>; else goto <D.29118>;
    <D.29117>:
    iftmp.6 = 1;
    goto <D.29119>;
    <D.29118>:
    iftmp.6 = 0;
    <D.29119>:
    D.29125 = iftmp.6 != 0;
    D.29126 = (long int) D.29125;
    D.29127 = __builtin_expect (D.29126, 0);
    if (D.29127 != 0) goto <D.29128>; else goto <D.29129>;
    <D.29128>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3200, "method->is_inflated && mono_method_get_context (method)->method_inst");
    <D.29129>:
    mrgctx_loc = mono_get_vtable_var (cfg);
    D.29082 = cfg->mempool;
    mrgctx_var = mono_mempool_alloc (D.29082, 80);
    mrgctx_var->data.op[1].const_val = 0;
    D.29130 = mrgctx_var->data.op[1].const_val;
    mrgctx_var->data.op[0].const_val = D.29130;
    mrgctx_var->prev = 0B;
    D.29131 = mrgctx_var->prev;
    mrgctx_var->next = D.29131;
    mrgctx_var->opcode = 424;
    mrgctx_var->flags = 0;
    mrgctx_var->type = 0;
    mrgctx_var->dreg = -1;
    mrgctx_var->sreg3 = -1;
    D.29132 = mrgctx_var->sreg3;
    mrgctx_var->sreg2 = D.29132;
    D.29133 = mrgctx_var->sreg2;
    mrgctx_var->sreg1 = D.29133;
    D.29087 = cfg->ip;
    mrgctx_var->cil_code = D.29087;
    D.29134 = cfg->varinfo;
    D.29135 = mrgctx_loc->data.op[0].const_val;
    D.29136 = (long unsigned int) D.29135;
    D.29137 = D.29136 * 8;
    D.29138 = D.29134 + D.29137;
    D.29139 = *D.29138;
    D.29140 = D.29139->data.op[1].vtype;
    D.29141 = mono_type_to_regmove (cfg, D.29140);
    D.29142 = (short unsigned int) D.29141;
    mrgctx_var->opcode = D.29142;
    D.29134 = cfg->varinfo;
    D.29135 = mrgctx_loc->data.op[0].const_val;
    D.29136 = (long unsigned int) D.29135;
    D.29137 = D.29136 * 8;
    D.29138 = D.29134 + D.29137;
    D.29139 = *D.29138;
    D.29140 = D.29139->data.op[1].vtype;
    type_to_eval_stack_type (cfg, D.29140, mrgctx_var);
    D.29134 = cfg->varinfo;
    D.29135 = mrgctx_loc->data.op[0].const_val;
    D.29136 = (long unsigned int) D.29135;
    D.29137 = D.29136 * 8;
    D.29138 = D.29134 + D.29137;
    D.29139 = *D.29138;
    D.29143 = D.29139->klass;
    mrgctx_var->klass = D.29143;
    D.29134 = cfg->varinfo;
    D.29135 = mrgctx_loc->data.op[0].const_val;
    D.29136 = (long unsigned int) D.29135;
    D.29137 = D.29136 * 8;
    D.29138 = D.29134 + D.29137;
    D.29139 = *D.29138;
    D.29144 = D.29139->dreg;
    mrgctx_var->sreg1 = D.29144;
    D.29145 = mrgctx_var->type;
    D.29146 = (<unnamed type>) D.29145;
    D.29147 = alloc_dreg (cfg, D.29146);
    D.29148 = (int) D.29147;
    mrgctx_var->dreg = D.29148;
    D.29149 = mrgctx_var->opcode;
    if (D.29149 == 427) goto <D.29150>; else goto <D.29151>;
    <D.29150>:
    D.29134 = cfg->varinfo;
    D.29135 = mrgctx_loc->data.op[0].const_val;
    D.29136 = (long unsigned int) D.29135;
    D.29137 = D.29136 * 8;
    D.29138 = D.29134 + D.29137;
    D.29139 = *D.29138;
    D.29140 = D.29139->data.op[1].vtype;
    D.29152 = mono_class_from_mono_type (D.29140);
    mrgctx_var->klass = D.29152;
    <D.29151>:
    D.29104 = cfg->cbb;
    D.29105 = D.29104->last_ins;
    if (D.29105 != 0B) goto <D.29153>; else goto <D.29154>;
    <D.29153>:
    D.29104 = cfg->cbb;
    D.29105 = D.29104->last_ins;
    D.29105->next = mrgctx_var;
    D.29104 = cfg->cbb;
    D.29105 = D.29104->last_ins;
    mrgctx_var->prev = D.29105;
    D.29104 = cfg->cbb;
    D.29104->last_ins = mrgctx_var;
    goto <D.29155>;
    <D.29154>:
    D.29104 = cfg->cbb;
    D.29104 = cfg->cbb;
    D.29104->last_ins = mrgctx_var;
    D.29105 = D.29104->last_ins;
    D.29104->code = D.29105;
    <D.29155>:
    D.29156 = mrgctx_var;
    return D.29156;
  }
  <D.29110>:
  D.29069 = method->flags;
  D.29070 = (int) D.29069;
  D.29071 = D.29070 & 16;
  if (D.29071 != 0) goto <D.29157>; else goto <D.29159>;
  <D.29159>:
  D.29077 = method->klass;
  D.29078 = BIT_FIELD_REF <*D.29077, 64, 256>;
  D.29079 = D.29078 & 1152921504606846976;
  if (D.29079 != 0) goto <D.29157>; else goto <D.29158>;
  <D.29157>:
  {
    struct MonoInst * vtable_loc;
    struct MonoInst * vtable_var;

    D.29111 = this != 0B;
    D.29112 = (long int) D.29111;
    D.29113 = __builtin_expect (D.29112, 0);
    if (D.29113 != 0) goto <D.29160>; else goto <D.29161>;
    <D.29160>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3209, "!this");
    <D.29161>:
    vtable_loc = mono_get_vtable_var (cfg);
    D.29082 = cfg->mempool;
    vtable_var = mono_mempool_alloc (D.29082, 80);
    vtable_var->data.op[1].const_val = 0;
    D.29162 = vtable_var->data.op[1].const_val;
    vtable_var->data.op[0].const_val = D.29162;
    vtable_var->prev = 0B;
    D.29163 = vtable_var->prev;
    vtable_var->next = D.29163;
    vtable_var->opcode = 424;
    vtable_var->flags = 0;
    vtable_var->type = 0;
    vtable_var->dreg = -1;
    vtable_var->sreg3 = -1;
    D.29164 = vtable_var->sreg3;
    vtable_var->sreg2 = D.29164;
    D.29165 = vtable_var->sreg2;
    vtable_var->sreg1 = D.29165;
    D.29087 = cfg->ip;
    vtable_var->cil_code = D.29087;
    D.29134 = cfg->varinfo;
    D.29166 = vtable_loc->data.op[0].const_val;
    D.29167 = (long unsigned int) D.29166;
    D.29168 = D.29167 * 8;
    D.29169 = D.29134 + D.29168;
    D.29170 = *D.29169;
    D.29171 = D.29170->data.op[1].vtype;
    D.29172 = mono_type_to_regmove (cfg, D.29171);
    D.29173 = (short unsigned int) D.29172;
    vtable_var->opcode = D.29173;
    D.29134 = cfg->varinfo;
    D.29166 = vtable_loc->data.op[0].const_val;
    D.29167 = (long unsigned int) D.29166;
    D.29168 = D.29167 * 8;
    D.29169 = D.29134 + D.29168;
    D.29170 = *D.29169;
    D.29171 = D.29170->data.op[1].vtype;
    type_to_eval_stack_type (cfg, D.29171, vtable_var);
    D.29134 = cfg->varinfo;
    D.29166 = vtable_loc->data.op[0].const_val;
    D.29167 = (long unsigned int) D.29166;
    D.29168 = D.29167 * 8;
    D.29169 = D.29134 + D.29168;
    D.29170 = *D.29169;
    D.29174 = D.29170->klass;
    vtable_var->klass = D.29174;
    D.29134 = cfg->varinfo;
    D.29166 = vtable_loc->data.op[0].const_val;
    D.29167 = (long unsigned int) D.29166;
    D.29168 = D.29167 * 8;
    D.29169 = D.29134 + D.29168;
    D.29170 = *D.29169;
    D.29175 = D.29170->dreg;
    vtable_var->sreg1 = D.29175;
    D.29176 = vtable_var->type;
    D.29177 = (<unnamed type>) D.29176;
    D.29178 = alloc_dreg (cfg, D.29177);
    D.29179 = (int) D.29178;
    vtable_var->dreg = D.29179;
    D.29180 = vtable_var->opcode;
    if (D.29180 == 427) goto <D.29181>; else goto <D.29182>;
    <D.29181>:
    D.29134 = cfg->varinfo;
    D.29166 = vtable_loc->data.op[0].const_val;
    D.29167 = (long unsigned int) D.29166;
    D.29168 = D.29167 * 8;
    D.29169 = D.29134 + D.29168;
    D.29170 = *D.29169;
    D.29171 = D.29170->data.op[1].vtype;
    D.29183 = mono_class_from_mono_type (D.29171);
    vtable_var->klass = D.29183;
    <D.29182>:
    D.29104 = cfg->cbb;
    D.29105 = D.29104->last_ins;
    if (D.29105 != 0B) goto <D.29184>; else goto <D.29185>;
    <D.29184>:
    D.29104 = cfg->cbb;
    D.29105 = D.29104->last_ins;
    D.29105->next = vtable_var;
    D.29104 = cfg->cbb;
    D.29105 = D.29104->last_ins;
    vtable_var->prev = D.29105;
    D.29104 = cfg->cbb;
    D.29104->last_ins = vtable_var;
    goto <D.29186>;
    <D.29185>:
    D.29104 = cfg->cbb;
    D.29104 = cfg->cbb;
    D.29104->last_ins = vtable_var;
    D.29105 = D.29104->last_ins;
    D.29104->code = D.29105;
    <D.29186>:
    D.29120 = BIT_FIELD_REF <*method, 64, 256>;
    D.29121 = D.29120 & 2251799813685248;
    if (D.29121 != 0) goto <D.29187>; else goto <D.29188>;
    <D.29187>:
    D.29189 = mono_method_get_context (method);
    D.29190 = D.29189->method_inst;
    if (D.29190 != 0B) goto <D.29191>; else goto <D.29192>;
    <D.29191>:
    {
      struct MonoInst * mrgctx_var;
      int vtable_reg;

      mrgctx_var = vtable_var;
      D.29193 = alloc_preg (cfg);
      vtable_reg = (int) D.29193;
      D.29082 = cfg->mempool;
      vtable_var = mono_mempool_alloc (D.29082, 80);
      vtable_var->data.op[1].const_val = 0;
      D.29162 = vtable_var->data.op[1].const_val;
      vtable_var->data.op[0].const_val = D.29162;
      vtable_var->prev = 0B;
      D.29163 = vtable_var->prev;
      vtable_var->next = D.29163;
      vtable_var->opcode = 388;
      vtable_var->flags = 0;
      vtable_var->type = 0;
      vtable_var->dreg = -1;
      vtable_var->sreg3 = -1;
      D.29164 = vtable_var->sreg3;
      vtable_var->sreg2 = D.29164;
      D.29165 = vtable_var->sreg2;
      vtable_var->sreg1 = D.29165;
      D.29087 = cfg->ip;
      vtable_var->cil_code = D.29087;
      vtable_var->dreg = vtable_reg;
      D.29194 = mrgctx_var->dreg;
      vtable_var->sreg1 = D.29194;
      vtable_var->data.op[0].const_val = 0;
      vtable_var->type = 1;
      D.29104 = cfg->cbb;
      D.29105 = D.29104->last_ins;
      if (D.29105 != 0B) goto <D.29195>; else goto <D.29196>;
      <D.29195>:
      D.29104 = cfg->cbb;
      D.29105 = D.29104->last_ins;
      D.29105->next = vtable_var;
      D.29104 = cfg->cbb;
      D.29105 = D.29104->last_ins;
      vtable_var->prev = D.29105;
      D.29104 = cfg->cbb;
      D.29104->last_ins = vtable_var;
      goto <D.29197>;
      <D.29196>:
      D.29104 = cfg->cbb;
      D.29104 = cfg->cbb;
      D.29104->last_ins = vtable_var;
      D.29105 = D.29104->last_ins;
      D.29104->code = D.29105;
      <D.29197>:
      vtable_var->type = 3;
    }
    <D.29192>:
    <D.29188>:
    D.29156 = vtable_var;
    return D.29156;
  }
  <D.29158>:
  {
    struct MonoInst * ins;
    int vtable_reg;

    D.29198 = alloc_preg (cfg);
    vtable_reg = (int) D.29198;
    D.29082 = cfg->mempool;
    ins = mono_mempool_alloc (D.29082, 80);
    ins->data.op[1].const_val = 0;
    D.29199 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.29199;
    ins->prev = 0B;
    D.29200 = ins->prev;
    ins->next = D.29200;
    ins->opcode = 388;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.29201 = ins->sreg3;
    ins->sreg2 = D.29201;
    D.29202 = ins->sreg2;
    ins->sreg1 = D.29202;
    D.29087 = cfg->ip;
    ins->cil_code = D.29087;
    ins->dreg = vtable_reg;
    D.29203 = this->dreg;
    ins->sreg1 = D.29203;
    ins->data.op[0].const_val = 0;
    ins->type = 1;
    D.29104 = cfg->cbb;
    D.29105 = D.29104->last_ins;
    if (D.29105 != 0B) goto <D.29204>; else goto <D.29205>;
    <D.29204>:
    D.29104 = cfg->cbb;
    D.29105 = D.29104->last_ins;
    D.29105->next = ins;
    D.29104 = cfg->cbb;
    D.29105 = D.29104->last_ins;
    ins->prev = D.29105;
    D.29104 = cfg->cbb;
    D.29104->last_ins = ins;
    goto <D.29206>;
    <D.29205>:
    D.29104 = cfg->cbb;
    D.29104 = cfg->cbb;
    D.29104->last_ins = ins;
    D.29105 = D.29104->last_ins;
    D.29104->code = D.29105;
    <D.29206>:
    D.29156 = ins;
    return D.29156;
  }
}


mono_get_vtable_var (struct MonoCompile * cfg)
{
  struct MonoGenericSharingContext * D.29208;
  _Bool D.29209;
  long int D.29210;
  long int D.29211;
  struct MonoInst * D.29214;
  struct MonoClass * D.29217;
  struct MonoType * D.29218;
  struct MonoInst * D.29219;
  unsigned char D.29220;
  unsigned char D.29221;
  struct MonoInst * D.29222;

  D.29208 = cfg->generic_sharing_context;
  D.29209 = D.29208 == 0B;
  D.29210 = (long int) D.29209;
  D.29211 = __builtin_expect (D.29210, 0);
  if (D.29211 != 0) goto <D.29212>; else goto <D.29213>;
  <D.29212>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1161, "cfg->generic_sharing_context");
  <D.29213>:
  D.29214 = cfg->rgctx_var;
  if (D.29214 == 0B) goto <D.29215>; else goto <D.29216>;
  <D.29215>:
  D.29217 = mono_defaults.int_class;
  D.29218 = &D.29217->byval_arg;
  D.29219 = mono_compile_create_var (cfg, D.29218, 329);
  cfg->rgctx_var = D.29219;
  D.29214 = cfg->rgctx_var;
  D.29214 = cfg->rgctx_var;
  D.29220 = D.29214->flags;
  D.29221 = D.29220 | 4;
  D.29214->flags = D.29221;
  <D.29216>:
  D.29222 = cfg->rgctx_var;
  return D.29222;
}


emit_rgctx_fetch (struct MonoCompile * cfg, struct MonoInst * rgctx, struct MonoJumpInfoRgctxEntry * entry)
{
  struct MonoInst * D.29224;
  struct MonoMethodSignature * helper_sig_rgctx_lazy_fetch_trampoline.7;

  helper_sig_rgctx_lazy_fetch_trampoline.7 = helper_sig_rgctx_lazy_fetch_trampoline;
  D.29224 = mono_emit_abs_call (cfg, 35, entry, helper_sig_rgctx_lazy_fetch_trampoline.7, &rgctx);
  return D.29224;
}


mono_emit_abs_call (struct MonoCompile * cfg, MonoJumpInfoType patch_type, const void * data, struct MonoMethodSignature * sig, struct MonoInst * * args)
{
  struct MonoMemPool * D.29227;
  struct GHashTable * D.29228;
  struct GHashTable * D.29231;
  struct MonoInst * D.29232;
  struct MonoJumpInfo * ji;
  struct MonoInst * ins;

  D.29227 = cfg->mempool;
  ji = mono_patch_info_new (D.29227, 0, patch_type, data);
  D.29228 = cfg->abs_patches;
  if (D.29228 == 0B) goto <D.29229>; else goto <D.29230>;
  <D.29229>:
  D.29231 = monoeg_g_hash_table_new (0B, 0B);
  cfg->abs_patches = D.29231;
  <D.29230>:
  D.29228 = cfg->abs_patches;
  monoeg_g_hash_table_insert_replace (D.29228, ji, ji, 0);
  ins = mono_emit_native_call (cfg, ji, sig, args);
  MEM[(struct MonoCallInst *)ins].fptr_is_patch = 1;
  D.29232 = ins;
  return D.29232;
}


mono_patch_info_new (struct MonoMemPool * mp, int ip, MonoJumpInfoType type, const void * target)
{
  struct MonoJumpInfo * D.29234;
  struct MonoJumpInfo * ji;

  ji = mono_mempool_alloc (mp, 40);
  ji->ip.i = ip;
  ji->type = type;
  ji->data.target = target;
  D.29234 = ji;
  return D.29234;
}


mono_emit_calli (struct MonoCompile * cfg, struct MonoMethodSignature * sig, struct MonoInst * * args, struct MonoInst * addr, struct MonoInst * imt_arg, struct MonoInst * rgctx_arg)
{
  unsigned int D.29238;
  struct MonoMemPool * D.29239;
  long int D.29240;
  struct MonoInst * D.29241;
  int D.29242;
  int D.29243;
  const unsigned char * D.29244;
  int D.29245;
  struct MonoBasicBlock * D.29246;
  struct MonoInst * D.29247;
  _Bool D.29251;
  int D.29252;
  int D.29253;
  struct MonoInst * D.29261;
  struct MonoCallInst * call;
  int rgctx_reg;

  rgctx_reg = -1;
  if (rgctx_arg != 0B) goto <D.29236>; else goto <D.29237>;
  <D.29236>:
  D.29238 = mono_alloc_preg (cfg);
  rgctx_reg = (int) D.29238;
  {
    struct MonoInst * inst;

    D.29239 = cfg->mempool;
    inst = mono_mempool_alloc (D.29239, 80);
    inst->data.op[1].const_val = 0;
    D.29240 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.29240;
    inst->prev = 0B;
    D.29241 = inst->prev;
    inst->next = D.29241;
    inst->opcode = 424;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.29242 = inst->sreg3;
    inst->sreg2 = D.29242;
    D.29243 = inst->sreg2;
    inst->sreg1 = D.29243;
    D.29244 = cfg->ip;
    inst->cil_code = D.29244;
    inst->dreg = rgctx_reg;
    D.29245 = rgctx_arg->dreg;
    inst->sreg1 = D.29245;
    D.29246 = cfg->cbb;
    D.29247 = D.29246->last_ins;
    if (D.29247 != 0B) goto <D.29248>; else goto <D.29249>;
    <D.29248>:
    D.29246 = cfg->cbb;
    D.29247 = D.29246->last_ins;
    D.29247->next = inst;
    D.29246 = cfg->cbb;
    D.29247 = D.29246->last_ins;
    inst->prev = D.29247;
    D.29246 = cfg->cbb;
    D.29246->last_ins = inst;
    goto <D.29250>;
    <D.29249>:
    D.29246 = cfg->cbb;
    D.29246 = cfg->cbb;
    D.29246->last_ins = inst;
    D.29247 = D.29246->last_ins;
    D.29246->code = D.29247;
    <D.29250>:
  }
  <D.29237>:
  D.29251 = rgctx_arg != 0B;
  D.29252 = (int) D.29251;
  call = mono_emit_call_args (cfg, sig, args, 1, 0, 0, D.29252, 0);
  D.29253 = addr->dreg;
  call->inst.sreg1 = D.29253;
  if (imt_arg != 0B) goto <D.29254>; else goto <D.29255>;
  <D.29254>:
  emit_imt_argument (cfg, call, 0B, imt_arg);
  <D.29255>:
  D.29246 = cfg->cbb;
  D.29247 = D.29246->last_ins;
  if (D.29247 != 0B) goto <D.29256>; else goto <D.29257>;
  <D.29256>:
  D.29246 = cfg->cbb;
  D.29247 = D.29246->last_ins;
  D.29247->next = call;
  D.29246 = cfg->cbb;
  D.29247 = D.29246->last_ins;
  MEM[(struct MonoInst *)call].prev = D.29247;
  D.29246 = cfg->cbb;
  D.29246->last_ins = call;
  goto <D.29258>;
  <D.29257>:
  D.29246 = cfg->cbb;
  D.29246 = cfg->cbb;
  D.29246->last_ins = call;
  D.29247 = D.29246->last_ins;
  D.29246->code = D.29247;
  <D.29258>:
  if (rgctx_arg != 0B) goto <D.29259>; else goto <D.29260>;
  <D.29259>:
  set_rgctx_arg (cfg, call, rgctx_reg, rgctx_arg);
  <D.29260>:
  D.29261 = call;
  return D.29261;
}


mono_emit_call_args (struct MonoCompile * cfg, struct MonoMethodSignature * sig, struct MonoInst * * args, int calli, int virtual, int tail, int rgctx, int unbox_trampoline)
{
  struct MonoMemPool * D.29265;
  int D.29266;
  int D.29267;
  const unsigned char * D.29268;
  struct MonoType * D.29270;
  struct MonoGenericSharingContext * D.29271;
  int D.29272;
  short unsigned int D.29273;
  unsigned char D.29274;
  <unnamed-unsigned:1> D.29275;
  struct MonoInst * D.29276;
  int D.29279;
  struct MonoInst * D.29282;
  int D.29284;
  <unnamed-unsigned:1> D.29287;
  int D.29288;
  long int D.29289;
  struct MonoInst * D.29290;
  int D.29291;
  int D.29292;
  unsigned int D.29293;
  int D.29294;
  struct MonoBasicBlock * D.29295;
  struct MonoInst * D.29296;
  int D.29300;
  int D.29302;
  unsigned char D.29305;
  <unnamed type> D.29306;
  unsigned int D.29307;
  int D.29308;
  unsigned char D.29309;
  <unnamed-unsigned:1> D.29310;
  unsigned int D.29311;
  unsigned int D.29312;
  unsigned int D.29313;
  unsigned int D.29314;
  unsigned int D.29315;
  struct MonoCallInst * D.29316;
  struct MonoType * sig_ret;
  struct MonoCallInst * call;

  if (tail != 0) goto <D.29263>; else goto <D.29264>;
  <D.29263>:
  D.29265 = cfg->mempool;
  call = mono_mempool_alloc0 (D.29265, 192);
  call->inst.opcode = 444;
  call->inst.dreg = -1;
  call->inst.sreg3 = -1;
  D.29266 = call->inst.sreg3;
  call->inst.sreg2 = D.29266;
  D.29267 = call->inst.sreg2;
  call->inst.sreg1 = D.29267;
  D.29268 = cfg->ip;
  call->inst.cil_code = D.29268;
  goto <D.29269>;
  <D.29264>:
  D.29265 = cfg->mempool;
  call = mono_mempool_alloc0 (D.29265, 192);
  D.29270 = sig->ret;
  D.29271 = cfg->generic_sharing_context;
  D.29272 = ret_type_to_call_opcode (D.29270, calli, virtual, D.29271);
  D.29273 = (short unsigned int) D.29272;
  call->inst.opcode = D.29273;
  call->inst.dreg = -1;
  call->inst.sreg3 = -1;
  D.29266 = call->inst.sreg3;
  call->inst.sreg2 = D.29266;
  D.29267 = call->inst.sreg2;
  call->inst.sreg1 = D.29267;
  D.29268 = cfg->ip;
  call->inst.cil_code = D.29268;
  <D.29269>:
  call->args = args;
  call->signature = sig;
  D.29274 = (unsigned char) rgctx;
  D.29275 = (<unnamed-unsigned:1>) D.29274;
  call->rgctx_reg = D.29275;
  D.29270 = sig->ret;
  sig_ret = mini_replace_type (D.29270);
  D.29276 = &call->inst;
  type_to_eval_stack_type (cfg, sig_ret, D.29276);
  if (tail != 0) goto <D.29277>; else goto <D.29278>;
  <D.29277>:
  D.29279 = mini_type_is_vtype (cfg, sig_ret);
  if (D.29279 != 0) goto <D.29280>; else goto <D.29281>;
  <D.29280>:
  D.29282 = cfg->vret_addr;
  call->vret_var = D.29282;
  <D.29281>:
  goto <D.29283>;
  <D.29278>:
  D.29284 = mini_type_is_vtype (cfg, sig_ret);
  if (D.29284 != 0) goto <D.29285>; else goto <D.29286>;
  <D.29285>:
  {
    struct MonoInst * temp;
    struct MonoInst * loada;

    temp = mono_compile_create_var (cfg, sig_ret, 329);
    D.29287 = sig->pinvoke;
    D.29288 = (int) D.29287;
    temp->backend.is_pinvoke = D.29288;
    D.29265 = cfg->mempool;
    loada = mono_mempool_alloc (D.29265, 80);
    loada->data.op[1].const_val = 0;
    D.29289 = loada->data.op[1].const_val;
    loada->data.op[0].const_val = D.29289;
    loada->prev = 0B;
    D.29290 = loada->prev;
    loada->next = D.29290;
    loada->opcode = 334;
    loada->flags = 0;
    loada->type = 0;
    loada->dreg = -1;
    loada->sreg3 = -1;
    D.29291 = loada->sreg3;
    loada->sreg2 = D.29291;
    D.29292 = loada->sreg2;
    loada->sreg1 = D.29292;
    D.29268 = cfg->ip;
    loada->cil_code = D.29268;
    D.29293 = alloc_preg (cfg);
    D.29294 = (int) D.29293;
    loada->dreg = D.29294;
    loada->data.op[0].p = temp;
    loada->data.op[1].p = call;
    D.29295 = cfg->cbb;
    D.29296 = D.29295->last_ins;
    if (D.29296 != 0B) goto <D.29297>; else goto <D.29298>;
    <D.29297>:
    D.29295 = cfg->cbb;
    D.29296 = D.29295->last_ins;
    D.29296->next = loada;
    D.29295 = cfg->cbb;
    D.29296 = D.29295->last_ins;
    loada->prev = D.29296;
    D.29295 = cfg->cbb;
    D.29295->last_ins = loada;
    goto <D.29299>;
    <D.29298>:
    D.29295 = cfg->cbb;
    D.29295 = cfg->cbb;
    D.29295->last_ins = loada;
    D.29296 = D.29295->last_ins;
    D.29295->code = D.29296;
    <D.29299>:
    D.29300 = temp->dreg;
    call->inst.dreg = D.29300;
    call->vret_var = loada;
  }
  goto <D.29301>;
  <D.29286>:
  D.29302 = mono_type_is_void (sig_ret);
  if (D.29302 == 0) goto <D.29303>; else goto <D.29304>;
  <D.29303>:
  D.29305 = call->inst.type;
  D.29306 = (<unnamed type>) D.29305;
  D.29307 = alloc_dreg (cfg, D.29306);
  D.29308 = (int) D.29307;
  call->inst.dreg = D.29308;
  <D.29304>:
  <D.29301>:
  <D.29283>:
  D.29309 = (unsigned char) unbox_trampoline;
  D.29310 = (<unnamed-unsigned:1>) D.29309;
  call->need_unbox_trampoline = D.29310;
  mono_arch_emit_call (cfg, call);
  D.29311 = call->stack_usage;
  D.29312 = cfg->param_area;
  D.29313 = MAX_EXPR <D.29311, D.29312>;
  cfg->param_area = D.29313;
  D.29314 = cfg->flags;
  D.29315 = D.29314 | 2;
  cfg->flags = D.29315;
  D.29316 = call;
  return D.29316;
}


ret_type_to_call_opcode (struct MonoType * type, int calli, int virt, struct MonoGenericSharingContext * gsctx)
{
  long unsigned int D.29318;
  long unsigned int D.29319;
  int D.29322;
  int iftmp.8;
  int iftmp.9;
  unsigned char D.29331;
  int D.29332;
  int iftmp.10;
  int iftmp.11;
  int iftmp.12;
  int iftmp.13;
  int iftmp.14;
  int iftmp.15;
  int iftmp.16;
  int iftmp.17;
  int iftmp.18;
  int iftmp.19;
  int iftmp.20;
  int iftmp.21;
  struct MonoClass * D.29381;
  long unsigned int D.29382;
  long unsigned int D.29383;
  int iftmp.22;
  int iftmp.23;
  int iftmp.24;
  int iftmp.25;
  struct MonoGenericClass * D.29402;
  struct MonoClass * D.29403;
  int iftmp.26;
  int iftmp.27;
  void handle_enum = <<< error >>>;

  D.29318 = BIT_FIELD_REF <*type, 64, 64>;
  D.29319 = D.29318 & 8589934592;
  if (D.29319 != 0) goto <D.29320>; else goto <D.29321>;
  <D.29320>:
  if (calli == 0) goto <D.29324>; else goto <D.29325>;
  <D.29324>:
  if (virt != 0) goto <D.29327>; else goto <D.29328>;
  <D.29327>:
  iftmp.9 = 348;
  goto <D.29329>;
  <D.29328>:
  iftmp.9 = 346;
  <D.29329>:
  iftmp.8 = iftmp.9;
  goto <D.29330>;
  <D.29325>:
  iftmp.8 = 347;
  <D.29330>:
  D.29322 = iftmp.8;
  return D.29322;
  <D.29321>:
  handle_enum:
  type = mini_get_basic_type_from_generic (gsctx, type);
  type = mini_replace_type (type);
  D.29331 = type->type;
  D.29332 = (int) D.29331;
  switch (D.29332) <default: <D.25739>, case 1: <D.25712>, case 2: <D.25715>, case 3: <D.25718>, case 4: <D.25713>, case 5: <D.25714>, case 6: <D.25716>, case 7: <D.25717>, case 8: <D.25719>, case 9: <D.25720>, case 10: <D.25730>, case 11: <D.25731>, case 12: <D.25732>, case 13: <D.25733>, case 14: <D.25726>, case 15: <D.25723>, case 17: <D.25734>, case 18: <D.25725>, case 19: <D.25737>, case 20: <D.25729>, case 21: <D.25736>, case 22: <D.25735>, case 24: <D.25721>, case 25: <D.25722>, case 27: <D.25724>, case 28: <D.25727>, case 29: <D.25728>, case 30: <D.25738>>
  <D.25712>:
  if (calli == 0) goto <D.29334>; else goto <D.29335>;
  <D.29334>:
  if (virt != 0) goto <D.29337>; else goto <D.29338>;
  <D.29337>:
  iftmp.11 = 345;
  goto <D.29339>;
  <D.29338>:
  iftmp.11 = 343;
  <D.29339>:
  iftmp.10 = iftmp.11;
  goto <D.29340>;
  <D.29335>:
  iftmp.10 = 344;
  <D.29340>:
  D.29322 = iftmp.10;
  return D.29322;
  <D.25713>:
  <D.25714>:
  <D.25715>:
  <D.25716>:
  <D.25717>:
  <D.25718>:
  <D.25719>:
  <D.25720>:
  if (calli == 0) goto <D.29342>; else goto <D.29343>;
  <D.29342>:
  if (virt != 0) goto <D.29345>; else goto <D.29346>;
  <D.29345>:
  iftmp.13 = 348;
  goto <D.29347>;
  <D.29346>:
  iftmp.13 = 346;
  <D.29347>:
  iftmp.12 = iftmp.13;
  goto <D.29348>;
  <D.29343>:
  iftmp.12 = 347;
  <D.29348>:
  D.29322 = iftmp.12;
  return D.29322;
  <D.25721>:
  <D.25722>:
  <D.25723>:
  <D.25724>:
  if (calli == 0) goto <D.29350>; else goto <D.29351>;
  <D.29350>:
  if (virt != 0) goto <D.29353>; else goto <D.29354>;
  <D.29353>:
  iftmp.15 = 348;
  goto <D.29355>;
  <D.29354>:
  iftmp.15 = 346;
  <D.29355>:
  iftmp.14 = iftmp.15;
  goto <D.29356>;
  <D.29351>:
  iftmp.14 = 347;
  <D.29356>:
  D.29322 = iftmp.14;
  return D.29322;
  <D.25725>:
  <D.25726>:
  <D.25727>:
  <D.25728>:
  <D.25729>:
  if (calli == 0) goto <D.29358>; else goto <D.29359>;
  <D.29358>:
  if (virt != 0) goto <D.29361>; else goto <D.29362>;
  <D.29361>:
  iftmp.17 = 348;
  goto <D.29363>;
  <D.29362>:
  iftmp.17 = 346;
  <D.29363>:
  iftmp.16 = iftmp.17;
  goto <D.29364>;
  <D.29359>:
  iftmp.16 = 347;
  <D.29364>:
  D.29322 = iftmp.16;
  return D.29322;
  <D.25730>:
  <D.25731>:
  if (calli == 0) goto <D.29366>; else goto <D.29367>;
  <D.29366>:
  if (virt != 0) goto <D.29369>; else goto <D.29370>;
  <D.29369>:
  iftmp.19 = 354;
  goto <D.29371>;
  <D.29370>:
  iftmp.19 = 352;
  <D.29371>:
  iftmp.18 = iftmp.19;
  goto <D.29372>;
  <D.29367>:
  iftmp.18 = 353;
  <D.29372>:
  D.29322 = iftmp.18;
  return D.29322;
  <D.25732>:
  <D.25733>:
  if (calli == 0) goto <D.29374>; else goto <D.29375>;
  <D.29374>:
  if (virt != 0) goto <D.29377>; else goto <D.29378>;
  <D.29377>:
  iftmp.21 = 351;
  goto <D.29379>;
  <D.29378>:
  iftmp.21 = 349;
  <D.29379>:
  iftmp.20 = iftmp.21;
  goto <D.29380>;
  <D.29375>:
  iftmp.20 = 350;
  <D.29380>:
  D.29322 = iftmp.20;
  return D.29322;
  <D.25734>:
  D.29381 = type->data.klass;
  D.29382 = BIT_FIELD_REF <*D.29381, 64, 256>;
  D.29383 = D.29382 & 576460752303423488;
  if (D.29383 != 0) goto <D.29384>; else goto <D.29385>;
  <D.29384>:
  D.29381 = type->data.klass;
  type = mono_class_enum_basetype (D.29381);
  goto handle_enum;
  <D.29385>:
  if (calli == 0) goto <D.29387>; else goto <D.29388>;
  <D.29387>:
  if (virt != 0) goto <D.29390>; else goto <D.29391>;
  <D.29390>:
  iftmp.23 = 357;
  goto <D.29392>;
  <D.29391>:
  iftmp.23 = 355;
  <D.29392>:
  iftmp.22 = iftmp.23;
  goto <D.29393>;
  <D.29388>:
  iftmp.22 = 356;
  <D.29393>:
  D.29322 = iftmp.22;
  return D.29322;
  <D.25735>:
  if (calli == 0) goto <D.29395>; else goto <D.29396>;
  <D.29395>:
  if (virt != 0) goto <D.29398>; else goto <D.29399>;
  <D.29398>:
  iftmp.25 = 357;
  goto <D.29400>;
  <D.29399>:
  iftmp.25 = 355;
  <D.29400>:
  iftmp.24 = iftmp.25;
  goto <D.29401>;
  <D.29396>:
  iftmp.24 = 356;
  <D.29401>:
  D.29322 = iftmp.24;
  return D.29322;
  <D.25736>:
  D.29402 = type->data.generic_class;
  D.29403 = D.29402->container_class;
  type = &D.29403->byval_arg;
  goto handle_enum;
  <D.25737>:
  <D.25738>:
  if (calli == 0) goto <D.29405>; else goto <D.29406>;
  <D.29405>:
  if (virt != 0) goto <D.29408>; else goto <D.29409>;
  <D.29408>:
  iftmp.27 = 357;
  goto <D.29410>;
  <D.29409>:
  iftmp.27 = 355;
  <D.29410>:
  iftmp.26 = iftmp.27;
  goto <D.29411>;
  <D.29406>:
  iftmp.26 = 356;
  <D.29411>:
  D.29322 = iftmp.26;
  return D.29322;
  <D.25739>:
  D.29331 = type->type;
  D.29332 = (int) D.29331;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in ret_type_to_call_opcode", D.29332);
  <D.25740>:
  goto <D.25740>;
  D.29322 = -1;
  return D.29322;
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.28;
  int iftmp.29;
  int D.29421;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.29414>; else goto <D.29415>;
  <D.29414>:
  if (__ret == 1) goto <D.29417>; else goto <D.29418>;
  <D.29417>:
  iftmp.29 = -1;
  goto <D.29419>;
  <D.29418>:
  iftmp.29 = 1;
  <D.29419>:
  iftmp.28 = iftmp.29;
  goto <D.29420>;
  <D.29415>:
  iftmp.28 = 0;
  <D.29420>:
  __ret = iftmp.28;
  D.29421 = __ret;
  return D.29421;
}


callvirt_to_call (int opcode)
{
  int D.29423;

  switch (opcode) <default: <D.25826>, case 345: <D.25822>, case 348: <D.25821>, case 351: <D.25823>, case 354: <D.25825>, case 357: <D.25824>>
  <D.25821>:
  D.29423 = 346;
  return D.29423;
  <D.25822>:
  D.29423 = 343;
  return D.29423;
  <D.25823>:
  D.29423 = 349;
  return D.29423;
  <D.25824>:
  D.29423 = 355;
  return D.29423;
  <D.25825>:
  D.29423 = 352;
  return D.29423;
  <D.25826>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 2288);
  D.29423 = -1;
  return D.29423;
}


mini_emit_load_intf_reg_vtable (struct MonoCompile * cfg, int intf_reg, int vtable_reg, struct MonoClass * klass)
{
  long unsigned int D.29425;
  long unsigned int D.29426;
  unsigned int D.29429;
  unsigned int D.29430;
  struct MonoMemPool * D.29431;
  long int D.29432;
  struct MonoInst * D.29433;
  guint16 iftmp.30;
  int D.29438;
  int D.29439;
  const unsigned char * D.29440;
  struct MonoBasicBlock * D.29441;
  struct MonoInst * D.29442;
  long int D.29446;
  struct MonoInst * D.29447;
  int D.29448;
  int D.29449;
  long int D.29453;
  struct MonoInst * D.29454;
  int D.29455;
  int D.29456;
  long int D.29461;
  struct MonoInst * D.29462;
  int D.29463;
  int D.29464;
  short unsigned int D.29465;
  int D.29466;
  int D.29467;
  int D.29468;
  long int D.29469;

  D.29425 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.29426 = D.29425 & 33554432;
  if (D.29426 != 0) goto <D.29427>; else goto <D.29428>;
  <D.29427>:
  {
    int ioffset_reg;
    int iid_reg;

    D.29429 = alloc_preg (cfg);
    ioffset_reg = (int) D.29429;
    D.29430 = alloc_preg (cfg);
    iid_reg = (int) D.29430;
    {
      struct MonoInst * inst;

      D.29431 = cfg->mempool;
      inst = mono_mempool_alloc (D.29431, 80);
      inst->data.op[1].const_val = 0;
      D.29432 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.29432;
      inst->prev = 0B;
      D.29433 = inst->prev;
      inst->next = D.29433;
      D.29425 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29426 = D.29425 & 33554432;
      if (D.29426 != 0) goto <D.29435>; else goto <D.29436>;
      <D.29435>:
      iftmp.30 = 732;
      goto <D.29437>;
      <D.29436>:
      iftmp.30 = 363;
      <D.29437>:
      inst->opcode = iftmp.30;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.29438 = inst->sreg3;
      inst->sreg2 = D.29438;
      D.29439 = inst->sreg2;
      inst->sreg1 = D.29439;
      D.29440 = cfg->ip;
      inst->cil_code = D.29440;
      inst->dreg = iid_reg;
      inst->data.op[0].p = klass;
      inst->data.op[1].const_val = 24;
      D.29441 = cfg->cbb;
      D.29442 = D.29441->last_ins;
      if (D.29442 != 0B) goto <D.29443>; else goto <D.29444>;
      <D.29443>:
      D.29441 = cfg->cbb;
      D.29442 = D.29441->last_ins;
      D.29442->next = inst;
      D.29441 = cfg->cbb;
      D.29442 = D.29441->last_ins;
      inst->prev = D.29442;
      D.29441 = cfg->cbb;
      D.29441->last_ins = inst;
      goto <D.29445>;
      <D.29444>:
      D.29441 = cfg->cbb;
      D.29441 = cfg->cbb;
      D.29441->last_ins = inst;
      D.29442 = D.29441->last_ins;
      D.29441->code = D.29442;
      <D.29445>:
    }
    {
      struct MonoInst * inst;

      D.29431 = cfg->mempool;
      inst = mono_mempool_alloc (D.29431, 80);
      inst->data.op[1].const_val = 0;
      D.29446 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.29446;
      inst->prev = 0B;
      D.29447 = inst->prev;
      inst->next = D.29447;
      inst->opcode = 479;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.29448 = inst->sreg3;
      inst->sreg2 = D.29448;
      D.29449 = inst->sreg2;
      inst->sreg1 = D.29449;
      D.29440 = cfg->ip;
      inst->cil_code = D.29440;
      inst->dreg = ioffset_reg;
      inst->sreg1 = iid_reg;
      inst->sreg2 = vtable_reg;
      D.29441 = cfg->cbb;
      D.29442 = D.29441->last_ins;
      if (D.29442 != 0B) goto <D.29450>; else goto <D.29451>;
      <D.29450>:
      D.29441 = cfg->cbb;
      D.29442 = D.29441->last_ins;
      D.29442->next = inst;
      D.29441 = cfg->cbb;
      D.29442 = D.29441->last_ins;
      inst->prev = D.29442;
      D.29441 = cfg->cbb;
      D.29441->last_ins = inst;
      goto <D.29452>;
      <D.29451>:
      D.29441 = cfg->cbb;
      D.29441 = cfg->cbb;
      D.29441->last_ins = inst;
      D.29442 = D.29441->last_ins;
      D.29441->code = D.29442;
      <D.29452>:
    }
    {
      struct MonoInst * inst;

      D.29431 = cfg->mempool;
      inst = mono_mempool_alloc (D.29431, 80);
      inst->data.op[1].const_val = 0;
      D.29453 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.29453;
      inst->prev = 0B;
      D.29454 = inst->prev;
      inst->next = D.29454;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.29455 = inst->sreg3;
      inst->sreg2 = D.29455;
      D.29456 = inst->sreg2;
      inst->sreg1 = D.29456;
      D.29440 = cfg->ip;
      inst->cil_code = D.29440;
      inst->dreg = intf_reg;
      inst->sreg1 = ioffset_reg;
      inst->data.op[0].const_val = 0;
      D.29441 = cfg->cbb;
      D.29442 = D.29441->last_ins;
      if (D.29442 != 0B) goto <D.29457>; else goto <D.29458>;
      <D.29457>:
      D.29441 = cfg->cbb;
      D.29442 = D.29441->last_ins;
      D.29442->next = inst;
      D.29441 = cfg->cbb;
      D.29442 = D.29441->last_ins;
      inst->prev = D.29442;
      D.29441 = cfg->cbb;
      D.29441->last_ins = inst;
      goto <D.29459>;
      <D.29458>:
      D.29441 = cfg->cbb;
      D.29441 = cfg->cbb;
      D.29441->last_ins = inst;
      D.29442 = D.29441->last_ins;
      D.29441->code = D.29442;
      <D.29459>:
    }
  }
  goto <D.29460>;
  <D.29428>:
  {
    struct MonoInst * inst;

    D.29431 = cfg->mempool;
    inst = mono_mempool_alloc (D.29431, 80);
    inst->data.op[1].const_val = 0;
    D.29461 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.29461;
    inst->prev = 0B;
    D.29462 = inst->prev;
    inst->next = D.29462;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.29463 = inst->sreg3;
    inst->sreg2 = D.29463;
    D.29464 = inst->sreg2;
    inst->sreg1 = D.29464;
    D.29440 = cfg->ip;
    inst->cil_code = D.29440;
    inst->dreg = intf_reg;
    inst->sreg1 = vtable_reg;
    D.29465 = klass->interface_id;
    D.29466 = (int) D.29465;
    D.29467 = D.29466 + 1;
    D.29468 = D.29467 * -8;
    D.29469 = (long int) D.29468;
    inst->data.op[0].const_val = D.29469;
    D.29441 = cfg->cbb;
    D.29442 = D.29441->last_ins;
    if (D.29442 != 0B) goto <D.29470>; else goto <D.29471>;
    <D.29470>:
    D.29441 = cfg->cbb;
    D.29442 = D.29441->last_ins;
    D.29442->next = inst;
    D.29441 = cfg->cbb;
    D.29442 = D.29441->last_ins;
    inst->prev = D.29442;
    D.29441 = cfg->cbb;
    D.29441->last_ins = inst;
    goto <D.29472>;
    <D.29471>:
    D.29441 = cfg->cbb;
    D.29441 = cfg->cbb;
    D.29441->last_ins = inst;
    D.29442 = D.29441->last_ins;
    D.29441->code = D.29442;
    <D.29472>:
  }
  <D.29460>:
}


emit_imt_argument (struct MonoCompile * cfg, struct MonoCallInst * call, struct MonoMethod * method, struct MonoInst * imt_arg)
{
  unsigned int D.29475;
  struct MonoMemPool * D.29478;
  long int D.29479;
  struct MonoInst * D.29480;
  int D.29481;
  int D.29482;
  const unsigned char * D.29483;
  int D.29484;
  struct MonoBasicBlock * D.29485;
  struct MonoInst * D.29486;
  long unsigned int D.29491;
  long unsigned int D.29492;
  long int D.29495;
  struct MonoInst * D.29496;
  guint16 iftmp.31;
  int D.29501;
  int D.29502;
  long int D.29507;
  struct MonoInst * D.29508;
  int D.29509;
  int D.29510;
  unsigned int D.29514;
  long int D.29517;
  struct MonoInst * D.29518;
  int D.29519;
  int D.29520;
  long int D.29527;
  struct MonoInst * D.29528;
  guint16 iftmp.32;
  int D.29533;
  int D.29534;
  long int D.29539;
  struct MonoInst * D.29540;
  int D.29541;
  int D.29542;
  int method_reg;

  if (0 != 0) goto <D.29473>; else goto <D.29474>;
  <D.29473>:
  D.29475 = alloc_preg (cfg);
  method_reg = (int) D.29475;
  if (imt_arg != 0B) goto <D.29476>; else goto <D.29477>;
  <D.29476>:
  {
    struct MonoInst * inst;

    D.29478 = cfg->mempool;
    inst = mono_mempool_alloc (D.29478, 80);
    inst->data.op[1].const_val = 0;
    D.29479 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.29479;
    inst->prev = 0B;
    D.29480 = inst->prev;
    inst->next = D.29480;
    inst->opcode = 424;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.29481 = inst->sreg3;
    inst->sreg2 = D.29481;
    D.29482 = inst->sreg2;
    inst->sreg1 = D.29482;
    D.29483 = cfg->ip;
    inst->cil_code = D.29483;
    inst->dreg = method_reg;
    D.29484 = imt_arg->dreg;
    inst->sreg1 = D.29484;
    D.29485 = cfg->cbb;
    D.29486 = D.29485->last_ins;
    if (D.29486 != 0B) goto <D.29487>; else goto <D.29488>;
    <D.29487>:
    D.29485 = cfg->cbb;
    D.29486 = D.29485->last_ins;
    D.29486->next = inst;
    D.29485 = cfg->cbb;
    D.29486 = D.29485->last_ins;
    inst->prev = D.29486;
    D.29485 = cfg->cbb;
    D.29485->last_ins = inst;
    goto <D.29489>;
    <D.29488>:
    D.29485 = cfg->cbb;
    D.29485 = cfg->cbb;
    D.29485->last_ins = inst;
    D.29486 = D.29485->last_ins;
    D.29485->code = D.29486;
    <D.29489>:
  }
  goto <D.29490>;
  <D.29477>:
  D.29491 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.29492 = D.29491 & 33554432;
  if (D.29492 != 0) goto <D.29493>; else goto <D.29494>;
  <D.29493>:
  {
    struct MonoInst * inst;

    D.29478 = cfg->mempool;
    inst = mono_mempool_alloc (D.29478, 80);
    inst->data.op[1].const_val = 0;
    D.29495 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.29495;
    inst->prev = 0B;
    D.29496 = inst->prev;
    inst->next = D.29496;
    D.29491 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.29492 = D.29491 & 33554432;
    if (D.29492 != 0) goto <D.29498>; else goto <D.29499>;
    <D.29498>:
    iftmp.31 = 732;
    goto <D.29500>;
    <D.29499>:
    iftmp.31 = 363;
    <D.29500>:
    inst->opcode = iftmp.31;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.29501 = inst->sreg3;
    inst->sreg2 = D.29501;
    D.29502 = inst->sreg2;
    inst->sreg1 = D.29502;
    D.29483 = cfg->ip;
    inst->cil_code = D.29483;
    inst->dreg = method_reg;
    inst->data.op[0].p = method;
    inst->data.op[1].const_val = 6;
    D.29485 = cfg->cbb;
    D.29486 = D.29485->last_ins;
    if (D.29486 != 0B) goto <D.29503>; else goto <D.29504>;
    <D.29503>:
    D.29485 = cfg->cbb;
    D.29486 = D.29485->last_ins;
    D.29486->next = inst;
    D.29485 = cfg->cbb;
    D.29486 = D.29485->last_ins;
    inst->prev = D.29486;
    D.29485 = cfg->cbb;
    D.29485->last_ins = inst;
    goto <D.29505>;
    <D.29504>:
    D.29485 = cfg->cbb;
    D.29485 = cfg->cbb;
    D.29485->last_ins = inst;
    D.29486 = D.29485->last_ins;
    D.29485->code = D.29486;
    <D.29505>:
  }
  goto <D.29506>;
  <D.29494>:
  {
    struct MonoInst * ins;

    D.29478 = cfg->mempool;
    ins = mono_mempool_alloc (D.29478, 80);
    ins->data.op[1].const_val = 0;
    D.29507 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.29507;
    ins->prev = 0B;
    D.29508 = ins->prev;
    ins->next = D.29508;
    ins->opcode = 363;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.29509 = ins->sreg3;
    ins->sreg2 = D.29509;
    D.29510 = ins->sreg2;
    ins->sreg1 = D.29510;
    D.29483 = cfg->ip;
    ins->cil_code = D.29483;
    ins->data.op[0].p = method;
    ins->dreg = method_reg;
    D.29485 = cfg->cbb;
    D.29486 = D.29485->last_ins;
    if (D.29486 != 0B) goto <D.29511>; else goto <D.29512>;
    <D.29511>:
    D.29485 = cfg->cbb;
    D.29486 = D.29485->last_ins;
    D.29486->next = ins;
    D.29485 = cfg->cbb;
    D.29486 = D.29485->last_ins;
    ins->prev = D.29486;
    D.29485 = cfg->cbb;
    D.29485->last_ins = ins;
    goto <D.29513>;
    <D.29512>:
    D.29485 = cfg->cbb;
    D.29485 = cfg->cbb;
    D.29485->last_ins = ins;
    D.29486 = D.29485->last_ins;
    D.29485->code = D.29486;
    <D.29513>:
  }
  <D.29506>:
  <D.29490>:
  mono_call_inst_add_outarg_reg (cfg, call, method_reg, 9, 0);
  return;
  <D.29474>:
  D.29514 = alloc_preg (cfg);
  method_reg = (int) D.29514;
  if (imt_arg != 0B) goto <D.29515>; else goto <D.29516>;
  <D.29515>:
  {
    struct MonoInst * inst;

    D.29478 = cfg->mempool;
    inst = mono_mempool_alloc (D.29478, 80);
    inst->data.op[1].const_val = 0;
    D.29517 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.29517;
    inst->prev = 0B;
    D.29518 = inst->prev;
    inst->next = D.29518;
    inst->opcode = 424;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.29519 = inst->sreg3;
    inst->sreg2 = D.29519;
    D.29520 = inst->sreg2;
    inst->sreg1 = D.29520;
    D.29483 = cfg->ip;
    inst->cil_code = D.29483;
    inst->dreg = method_reg;
    D.29484 = imt_arg->dreg;
    inst->sreg1 = D.29484;
    D.29485 = cfg->cbb;
    D.29486 = D.29485->last_ins;
    if (D.29486 != 0B) goto <D.29521>; else goto <D.29522>;
    <D.29521>:
    D.29485 = cfg->cbb;
    D.29486 = D.29485->last_ins;
    D.29486->next = inst;
    D.29485 = cfg->cbb;
    D.29486 = D.29485->last_ins;
    inst->prev = D.29486;
    D.29485 = cfg->cbb;
    D.29485->last_ins = inst;
    goto <D.29523>;
    <D.29522>:
    D.29485 = cfg->cbb;
    D.29485 = cfg->cbb;
    D.29485->last_ins = inst;
    D.29486 = D.29485->last_ins;
    D.29485->code = D.29486;
    <D.29523>:
  }
  goto <D.29524>;
  <D.29516>:
  D.29491 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.29492 = D.29491 & 33554432;
  if (D.29492 != 0) goto <D.29525>; else goto <D.29526>;
  <D.29525>:
  {
    struct MonoInst * inst;

    D.29478 = cfg->mempool;
    inst = mono_mempool_alloc (D.29478, 80);
    inst->data.op[1].const_val = 0;
    D.29527 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.29527;
    inst->prev = 0B;
    D.29528 = inst->prev;
    inst->next = D.29528;
    D.29491 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.29492 = D.29491 & 33554432;
    if (D.29492 != 0) goto <D.29530>; else goto <D.29531>;
    <D.29530>:
    iftmp.32 = 732;
    goto <D.29532>;
    <D.29531>:
    iftmp.32 = 363;
    <D.29532>:
    inst->opcode = iftmp.32;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.29533 = inst->sreg3;
    inst->sreg2 = D.29533;
    D.29534 = inst->sreg2;
    inst->sreg1 = D.29534;
    D.29483 = cfg->ip;
    inst->cil_code = D.29483;
    inst->dreg = method_reg;
    inst->data.op[0].p = method;
    inst->data.op[1].const_val = 6;
    D.29485 = cfg->cbb;
    D.29486 = D.29485->last_ins;
    if (D.29486 != 0B) goto <D.29535>; else goto <D.29536>;
    <D.29535>:
    D.29485 = cfg->cbb;
    D.29486 = D.29485->last_ins;
    D.29486->next = inst;
    D.29485 = cfg->cbb;
    D.29486 = D.29485->last_ins;
    inst->prev = D.29486;
    D.29485 = cfg->cbb;
    D.29485->last_ins = inst;
    goto <D.29537>;
    <D.29536>:
    D.29485 = cfg->cbb;
    D.29485 = cfg->cbb;
    D.29485->last_ins = inst;
    D.29486 = D.29485->last_ins;
    D.29485->code = D.29486;
    <D.29537>:
  }
  goto <D.29538>;
  <D.29526>:
  {
    struct MonoInst * ins;

    D.29478 = cfg->mempool;
    ins = mono_mempool_alloc (D.29478, 80);
    ins->data.op[1].const_val = 0;
    D.29539 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.29539;
    ins->prev = 0B;
    D.29540 = ins->prev;
    ins->next = D.29540;
    ins->opcode = 363;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.29541 = ins->sreg3;
    ins->sreg2 = D.29541;
    D.29542 = ins->sreg2;
    ins->sreg1 = D.29542;
    D.29483 = cfg->ip;
    ins->cil_code = D.29483;
    ins->data.op[0].p = method;
    ins->dreg = method_reg;
    D.29485 = cfg->cbb;
    D.29486 = D.29485->last_ins;
    if (D.29486 != 0B) goto <D.29543>; else goto <D.29544>;
    <D.29543>:
    D.29485 = cfg->cbb;
    D.29486 = D.29485->last_ins;
    D.29486->next = ins;
    D.29485 = cfg->cbb;
    D.29486 = D.29485->last_ins;
    ins->prev = D.29486;
    D.29485 = cfg->cbb;
    D.29485->last_ins = ins;
    goto <D.29545>;
    <D.29544>:
    D.29485 = cfg->cbb;
    D.29485 = cfg->cbb;
    D.29485->last_ins = ins;
    D.29486 = D.29485->last_ins;
    D.29485->code = D.29486;
    <D.29545>:
  }
  <D.29538>:
  <D.29524>:
  mono_call_inst_add_outarg_reg (cfg, call, method_reg, 9, 0);
}


set_rgctx_arg (struct MonoCompile * cfg, struct MonoCallInst * call, int rgctx_reg, struct MonoInst * rgctx_arg)
{
  mono_call_inst_add_outarg_reg (cfg, call, rgctx_reg, 9, 0);
  cfg->uses_rgctx_reg = 1;
  call->rgctx_reg = 1;
}


mono_emit_native_call (struct MonoCompile * cfg, const void * func, struct MonoMethodSignature * sig, struct MonoInst * * args)
{
  _Bool D.29547;
  long int D.29548;
  long int D.29549;
  struct MonoBasicBlock * D.29552;
  struct MonoInst * D.29553;
  struct MonoInst * D.29557;
  struct MonoCallInst * call;

  D.29547 = sig == 0B;
  D.29548 = (long int) D.29547;
  D.29549 = __builtin_expect (D.29548, 0);
  if (D.29549 != 0) goto <D.29550>; else goto <D.29551>;
  <D.29550>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 2775, "sig");
  <D.29551>:
  call = mono_emit_call_args (cfg, sig, args, 0, 0, 0, 0, 0);
  call->fptr = func;
  D.29552 = cfg->cbb;
  D.29553 = D.29552->last_ins;
  if (D.29553 != 0B) goto <D.29554>; else goto <D.29555>;
  <D.29554>:
  D.29552 = cfg->cbb;
  D.29553 = D.29552->last_ins;
  D.29553->next = call;
  D.29552 = cfg->cbb;
  D.29553 = D.29552->last_ins;
  MEM[(struct MonoInst *)call].prev = D.29553;
  D.29552 = cfg->cbb;
  D.29552->last_ins = call;
  goto <D.29556>;
  <D.29555>:
  D.29552 = cfg->cbb;
  D.29552 = cfg->cbb;
  D.29552->last_ins = call;
  D.29553 = D.29552->last_ins;
  D.29552->code = D.29553;
  <D.29556>:
  D.29557 = call;
  return D.29557;
}


__attribute__((visibility ("hidden")))
mono_emit_jit_icall (struct MonoCompile * cfg, const void * func, struct MonoInst * * args)
{
  _Bool D.29559;
  long int D.29560;
  long int D.29561;
  struct MonoInst * D.29564;
  const void * D.29565;
  struct MonoMethodSignature * D.29566;
  struct MonoJitICallInfo * info;

  info = mono_find_jit_icall_by_addr (func);
  D.29559 = info == 0B;
  D.29560 = (long int) D.29559;
  D.29561 = __builtin_expect (D.29560, 0);
  if (D.29561 != 0) goto <D.29562>; else goto <D.29563>;
  <D.29562>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 2790, "info");
  <D.29563>:
  D.29565 = mono_icall_get_wrapper (info);
  D.29566 = info->sig;
  D.29564 = mono_emit_native_call (cfg, D.29565, D.29566, args);
  return D.29564;
}


__attribute__((visibility ("hidden")))
mini_emit_stobj (struct MonoCompile * cfg, struct MonoInst * dest, struct MonoInst * src, struct MonoClass * klass, gboolean native)
{
  _Bool D.29568;
  long int D.29569;
  long int D.29570;
  int D.29573;
  _Bool D.29576;
  long int D.29577;
  long int D.29578;
  long unsigned int D.29586;
  long unsigned int D.29587;
  long unsigned int D.29590;
  long unsigned int D.29591;
  short unsigned int D.29597;
  int D.29599;
  unsigned int D.29600;
  unsigned int D.29601;
  unsigned int D.29606;
  unsigned int D.29607;
  unsigned int align.33;
  int align.34;
  int D.29611;
  struct MonoInst * D.29615;
  long unsigned int D.29617;
  struct MonoMemPool * D.29620;
  void * D.29621;
  struct MonoInst * D.29622;
  long int D.29623;
  struct MonoInst * D.29624;
  guint16 iftmp.35;
  int D.29629;
  int D.29630;
  const unsigned char * D.29631;
  unsigned int D.29632;
  int D.29633;
  struct MonoBasicBlock * D.29634;
  struct MonoInst * D.29635;
  void * D.29640;
  unsigned int D.29641;
  int D.29642;
  unsigned int n.36;
  int D.29655;
  int D.29656;
  void * D.29660;
  long int D.29661;
  unsigned int D.29662;
  int D.29663;
  struct MonoMethodSignature * D.29669;
  struct MonoInst * iargs[4];
  int context_used;
  int n;
  guint32 align;
  struct MonoMethod * memcpy_method;
  struct MonoInst * size_ins;
  struct MonoInst * memcpy_ins;

  try
    {
      align = 0;
      size_ins = 0B;
      memcpy_ins = 0B;
      D.29568 = klass == 0B;
      D.29569 = (long int) D.29568;
      D.29570 = __builtin_expect (D.29569, 0);
      if (D.29570 != 0) goto <D.29571>; else goto <D.29572>;
      <D.29571>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3060, "klass");
      <D.29572>:
      D.29573 = mini_is_gsharedvt_klass (cfg, klass);
      if (D.29573 != 0) goto <D.29574>; else goto <D.29575>;
      <D.29574>:
      D.29576 = native != 0;
      D.29577 = (long int) D.29576;
      D.29578 = __builtin_expect (D.29577, 0);
      if (D.29578 != 0) goto <D.29579>; else goto <D.29580>;
      <D.29579>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3067, "!native");
      <D.29580>:
      context_used = mini_class_check_context_used (cfg, klass);
      size_ins = emit_get_gsharedvt_info_klass (cfg, klass, 14);
      memcpy_ins = emit_get_gsharedvt_info_klass (cfg, klass, 22);
      <D.29575>:
      if (native != 0) goto <D.29581>; else goto <D.29582>;
      <D.29581>:
      n = mono_class_native_size (klass, &align);
      goto <D.29583>;
      <D.29582>:
      n = mono_class_value_size (klass, &align);
      <D.29583>:
      D.29586 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29587 = D.29586 & 8;
      if (D.29587 != 0) goto <D.29588>; else goto <D.29589>;
      <D.29588>:
      D.29590 = BIT_FIELD_REF <*klass, 64, 256>;
      D.29591 = D.29590 & 68719476736;
      if (D.29591 != 0) goto <D.29584>; else goto <D.29592>;
      <D.29592>:
      if (size_ins != 0B) goto <D.29584>; else goto <D.29585>;
      <D.29584>:
      if (native == 0) goto <D.29593>; else goto <D.29594>;
      <D.29593>:
      D.29597 = dest->opcode;
      if (D.29597 != 429) goto <D.29595>; else goto <D.29598>;
      <D.29598>:
      D.29599 = dest->sreg1;
      D.29600 = (unsigned int) D.29599;
      D.29601 = cfg->frame_reg;
      if (D.29600 != D.29601) goto <D.29595>; else goto <D.29596>;
      <D.29595>:
      D.29597 = dest->opcode;
      if (D.29597 != 314) goto <D.29602>; else goto <D.29603>;
      <D.29602>:
      {
        int context_used;

        iargs[0] = dest;
        iargs[1] = src;
        context_used = mini_class_check_context_used (cfg, klass);
        if (size_ins == 0B) goto <D.29605>; else goto <D.29604>;
        <D.29605>:
        D.29606 = cfg->opt;
        D.29607 = D.29606 & 2048;
        if (D.29607 != 0) goto <D.29608>; else goto <D.29604>;
        <D.29608>:
        align.33 = align;
        align.34 = (int) align.33;
        D.29611 = mono_emit_wb_aware_memcpy (cfg, klass, &iargs, n, align.34);
        if (D.29611 != 0) goto <D.29612>; else goto <D.29604>;
        <D.29612>:
        return;
        <D.29604>:
        if (context_used != 0) goto <D.29613>; else goto <D.29614>;
        <D.29613>:
        D.29615 = emit_get_rgctx_klass (cfg, context_used, klass, 1);
        iargs[2] = D.29615;
        goto <D.29616>;
        <D.29614>:
        D.29586 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.29617 = D.29586 & 33554432;
        if (D.29617 != 0) goto <D.29618>; else goto <D.29619>;
        <D.29618>:
        D.29620 = cfg->mempool;
        D.29621 = mono_mempool_alloc (D.29620, 80);
        iargs[2] = D.29621;
        D.29622 = iargs[2];
        D.29622 = iargs[2];
        D.29622->data.op[1].const_val = 0;
        D.29623 = D.29622->data.op[1].const_val;
        D.29622->data.op[0].const_val = D.29623;
        D.29622 = iargs[2];
        D.29622 = iargs[2];
        D.29622->prev = 0B;
        D.29624 = D.29622->prev;
        D.29622->next = D.29624;
        D.29622 = iargs[2];
        D.29586 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.29617 = D.29586 & 33554432;
        if (D.29617 != 0) goto <D.29626>; else goto <D.29627>;
        <D.29626>:
        iftmp.35 = 732;
        goto <D.29628>;
        <D.29627>:
        iftmp.35 = 363;
        <D.29628>:
        D.29622->opcode = iftmp.35;
        D.29622 = iargs[2];
        D.29622->flags = 0;
        D.29622 = iargs[2];
        D.29622->type = 0;
        D.29622 = iargs[2];
        D.29622->dreg = -1;
        D.29622 = iargs[2];
        D.29622 = iargs[2];
        D.29622 = iargs[2];
        D.29622->sreg3 = -1;
        D.29629 = D.29622->sreg3;
        D.29622->sreg2 = D.29629;
        D.29630 = D.29622->sreg2;
        D.29622->sreg1 = D.29630;
        D.29622 = iargs[2];
        D.29631 = cfg->ip;
        D.29622->cil_code = D.29631;
        D.29622 = iargs[2];
        D.29622->data.op[0].p = klass;
        D.29622 = iargs[2];
        D.29622->data.op[1].src = 11B;
        D.29622 = iargs[2];
        D.29622->type = 3;
        D.29622 = iargs[2];
        D.29632 = alloc_dreg (cfg, 3);
        D.29633 = (int) D.29632;
        D.29622->dreg = D.29633;
        D.29634 = cfg->cbb;
        D.29635 = D.29634->last_ins;
        if (D.29635 != 0B) goto <D.29636>; else goto <D.29637>;
        <D.29636>:
        D.29634 = cfg->cbb;
        D.29635 = D.29634->last_ins;
        D.29622 = iargs[2];
        D.29635->next = D.29622;
        D.29622 = iargs[2];
        D.29634 = cfg->cbb;
        D.29635 = D.29634->last_ins;
        D.29622->prev = D.29635;
        D.29634 = cfg->cbb;
        D.29622 = iargs[2];
        D.29634->last_ins = D.29622;
        goto <D.29638>;
        <D.29637>:
        D.29634 = cfg->cbb;
        D.29634 = cfg->cbb;
        D.29622 = iargs[2];
        D.29634->last_ins = D.29622;
        D.29635 = D.29634->last_ins;
        D.29634->code = D.29635;
        <D.29638>:
        goto <D.29639>;
        <D.29619>:
        D.29620 = cfg->mempool;
        D.29640 = mono_mempool_alloc (D.29620, 80);
        iargs[2] = D.29640;
        D.29622 = iargs[2];
        D.29622 = iargs[2];
        D.29622->data.op[1].const_val = 0;
        D.29623 = D.29622->data.op[1].const_val;
        D.29622->data.op[0].const_val = D.29623;
        D.29622 = iargs[2];
        D.29622 = iargs[2];
        D.29622->prev = 0B;
        D.29624 = D.29622->prev;
        D.29622->next = D.29624;
        D.29622 = iargs[2];
        D.29622->opcode = 363;
        D.29622 = iargs[2];
        D.29622->flags = 0;
        D.29622 = iargs[2];
        D.29622->type = 0;
        D.29622 = iargs[2];
        D.29622->dreg = -1;
        D.29622 = iargs[2];
        D.29622 = iargs[2];
        D.29622 = iargs[2];
        D.29622->sreg3 = -1;
        D.29629 = D.29622->sreg3;
        D.29622->sreg2 = D.29629;
        D.29630 = D.29622->sreg2;
        D.29622->sreg1 = D.29630;
        D.29622 = iargs[2];
        D.29631 = cfg->ip;
        D.29622->cil_code = D.29631;
        D.29622 = iargs[2];
        D.29622->data.op[0].p = klass;
        D.29622 = iargs[2];
        D.29622->type = 3;
        D.29622 = iargs[2];
        D.29641 = alloc_dreg (cfg, 3);
        D.29642 = (int) D.29641;
        D.29622->dreg = D.29642;
        D.29634 = cfg->cbb;
        D.29635 = D.29634->last_ins;
        if (D.29635 != 0B) goto <D.29643>; else goto <D.29644>;
        <D.29643>:
        D.29634 = cfg->cbb;
        D.29635 = D.29634->last_ins;
        D.29622 = iargs[2];
        D.29635->next = D.29622;
        D.29622 = iargs[2];
        D.29634 = cfg->cbb;
        D.29635 = D.29634->last_ins;
        D.29622->prev = D.29635;
        D.29634 = cfg->cbb;
        D.29622 = iargs[2];
        D.29634->last_ins = D.29622;
        goto <D.29645>;
        <D.29644>:
        D.29634 = cfg->cbb;
        D.29634 = cfg->cbb;
        D.29622 = iargs[2];
        D.29634->last_ins = D.29622;
        D.29635 = D.29634->last_ins;
        D.29634->code = D.29635;
        <D.29645>:
        mono_class_compute_gc_descriptor (klass);
        <D.29639>:
        <D.29616>:
        if (size_ins != 0B) goto <D.29646>; else goto <D.29647>;
        <D.29646>:
        mono_emit_jit_icall (cfg, mono_gsharedvt_value_copy, &iargs);
        goto <D.29648>;
        <D.29647>:
        mono_emit_jit_icall (cfg, mono_value_copy, &iargs);
        <D.29648>:
        return;
      }
      <D.29603>:
      <D.29596>:
      <D.29594>:
      <D.29585>:
      <D.29589>:
      if (size_ins == 0B) goto <D.29651>; else goto <D.29649>;
      <D.29651>:
      D.29606 = cfg->opt;
      D.29607 = D.29606 & 2048;
      if (D.29607 != 0) goto <D.29652>; else goto <D.29649>;
      <D.29652>:
      n.36 = (unsigned int) n;
      if (n.36 <= 40) goto <D.29654>; else goto <D.29649>;
      <D.29654>:
      D.29655 = dest->dreg;
      D.29656 = src->dreg;
      align.33 = align;
      align.34 = (int) align.33;
      mini_emit_memcpy (cfg, D.29655, 0, D.29656, 0, n, align.34);
      goto <D.29650>;
      <D.29649>:
      iargs[0] = dest;
      iargs[1] = src;
      if (size_ins != 0B) goto <D.29657>; else goto <D.29658>;
      <D.29657>:
      iargs[2] = size_ins;
      goto <D.29659>;
      <D.29658>:
      D.29620 = cfg->mempool;
      D.29660 = mono_mempool_alloc (D.29620, 80);
      iargs[2] = D.29660;
      D.29622 = iargs[2];
      D.29622 = iargs[2];
      D.29622->data.op[1].const_val = 0;
      D.29623 = D.29622->data.op[1].const_val;
      D.29622->data.op[0].const_val = D.29623;
      D.29622 = iargs[2];
      D.29622 = iargs[2];
      D.29622->prev = 0B;
      D.29624 = D.29622->prev;
      D.29622->next = D.29624;
      D.29622 = iargs[2];
      D.29622->opcode = 362;
      D.29622 = iargs[2];
      D.29622->flags = 0;
      D.29622 = iargs[2];
      D.29622->type = 0;
      D.29622 = iargs[2];
      D.29622->dreg = -1;
      D.29622 = iargs[2];
      D.29622 = iargs[2];
      D.29622 = iargs[2];
      D.29622->sreg3 = -1;
      D.29629 = D.29622->sreg3;
      D.29622->sreg2 = D.29629;
      D.29630 = D.29622->sreg2;
      D.29622->sreg1 = D.29630;
      D.29622 = iargs[2];
      D.29631 = cfg->ip;
      D.29622->cil_code = D.29631;
      D.29622 = iargs[2];
      D.29661 = (long int) n;
      D.29622->data.op[0].const_val = D.29661;
      D.29622 = iargs[2];
      D.29622->type = 1;
      D.29622 = iargs[2];
      D.29662 = alloc_dreg (cfg, 1);
      D.29663 = (int) D.29662;
      D.29622->dreg = D.29663;
      D.29634 = cfg->cbb;
      D.29635 = D.29634->last_ins;
      if (D.29635 != 0B) goto <D.29664>; else goto <D.29665>;
      <D.29664>:
      D.29634 = cfg->cbb;
      D.29635 = D.29634->last_ins;
      D.29622 = iargs[2];
      D.29635->next = D.29622;
      D.29622 = iargs[2];
      D.29634 = cfg->cbb;
      D.29635 = D.29634->last_ins;
      D.29622->prev = D.29635;
      D.29634 = cfg->cbb;
      D.29622 = iargs[2];
      D.29634->last_ins = D.29622;
      goto <D.29666>;
      <D.29665>:
      D.29634 = cfg->cbb;
      D.29634 = cfg->cbb;
      D.29622 = iargs[2];
      D.29634->last_ins = D.29622;
      D.29635 = D.29634->last_ins;
      D.29634->code = D.29635;
      <D.29666>:
      <D.29659>:
      memcpy_method = get_memcpy_method ();
      if (memcpy_ins != 0B) goto <D.29667>; else goto <D.29668>;
      <D.29667>:
      D.29669 = mono_method_signature (memcpy_method);
      mono_emit_calli (cfg, D.29669, &iargs, memcpy_ins, 0B, 0B);
      goto <D.29670>;
      <D.29668>:
      mono_emit_method_call (cfg, memcpy_method, &iargs, 0B);
      <D.29670>:
      <D.29650>:
    }
  finally
    {
      iargs = {CLOBBER};
      align = {CLOBBER};
    }
}


emit_get_gsharedvt_info_klass (struct MonoCompile * cfg, struct MonoClass * klass, MonoRgctxInfoType rgctx_type)
{
  struct MonoInst * D.29674;
  struct MonoType * D.29675;

  D.29675 = &klass->byval_arg;
  D.29674 = emit_get_gsharedvt_info (cfg, D.29675, rgctx_type);
  return D.29674;
}


emit_get_gsharedvt_info (struct MonoCompile * cfg, void * data, MonoRgctxInfoType rgctx_type)
{
  unsigned int D.29677;
  struct MonoMemPool * D.29678;
  long int D.29679;
  struct MonoInst * D.29680;
  int D.29681;
  int D.29682;
  const unsigned char * D.29683;
  struct MonoInst * D.29684;
  int D.29685;
  long unsigned int D.29686;
  long unsigned int D.29687;
  long unsigned int D.29688;
  long int D.29689;
  struct MonoBasicBlock * D.29690;
  struct MonoInst * D.29691;
  struct MonoInst * D.29695;
  struct MonoInst * ins;
  int idx;
  int dreg;

  idx = get_gsharedvt_info_slot (cfg, data, rgctx_type);
  D.29677 = alloc_preg (cfg);
  dreg = (int) D.29677;
  D.29678 = cfg->mempool;
  ins = mono_mempool_alloc (D.29678, 80);
  ins->data.op[1].const_val = 0;
  D.29679 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.29679;
  ins->prev = 0B;
  D.29680 = ins->prev;
  ins->next = D.29680;
  ins->opcode = 388;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.29681 = ins->sreg3;
  ins->sreg2 = D.29681;
  D.29682 = ins->sreg2;
  ins->sreg1 = D.29682;
  D.29683 = cfg->ip;
  ins->cil_code = D.29683;
  ins->dreg = dreg;
  D.29684 = cfg->gsharedvt_info_var;
  D.29685 = D.29684->dreg;
  ins->sreg1 = D.29685;
  D.29686 = (long unsigned int) idx;
  D.29687 = D.29686 + 1;
  D.29688 = D.29687 * 8;
  D.29689 = (long int) D.29688;
  ins->data.op[0].const_val = D.29689;
  ins->type = 1;
  D.29690 = cfg->cbb;
  D.29691 = D.29690->last_ins;
  if (D.29691 != 0B) goto <D.29692>; else goto <D.29693>;
  <D.29692>:
  D.29690 = cfg->cbb;
  D.29691 = D.29690->last_ins;
  D.29691->next = ins;
  D.29690 = cfg->cbb;
  D.29691 = D.29690->last_ins;
  ins->prev = D.29691;
  D.29690 = cfg->cbb;
  D.29690->last_ins = ins;
  goto <D.29694>;
  <D.29693>:
  D.29690 = cfg->cbb;
  D.29690 = cfg->cbb;
  D.29690->last_ins = ins;
  D.29691 = D.29690->last_ins;
  D.29690->code = D.29691;
  <D.29694>:
  D.29695 = ins;
  return D.29695;
}


get_gsharedvt_info_slot (struct MonoCompile * cfg, void * data, MonoRgctxInfoType rgctx_type)
{
  _Bool D.29697;
  long int D.29698;
  long int D.29699;
  struct GPtrArray * D.29702;
  void * * D.29703;
  long unsigned int D.29704;
  long unsigned int D.29705;
  void * * D.29706;
  <unnamed type> D.29707;
  void * D.29710;
  int D.29715;
  unsigned int D.29716;
  unsigned int i.37;
  struct MonoMemPool * D.29718;
  struct MonoGSharedVtMethodInfo * info;
  struct MonoRuntimeGenericContextInfoTemplate * template;
  int i;
  int idx;

  info = cfg->gsharedvt_info;
  D.29697 = info == 0B;
  D.29698 = (long int) D.29697;
  D.29699 = __builtin_expect (D.29698, 0);
  if (D.29699 != 0) goto <D.29700>; else goto <D.29701>;
  <D.29700>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3354, "info");
  <D.29701>:
  i = 0;
  goto <D.26198>;
  <D.26197>:
  {
    struct MonoRuntimeGenericContextInfoTemplate * otemplate;

    D.29702 = info->entries;
    D.29703 = D.29702->pdata;
    D.29704 = (long unsigned int) i;
    D.29705 = D.29704 * 8;
    D.29706 = D.29703 + D.29705;
    otemplate = *D.29706;
    D.29707 = otemplate->info_type;
    if (D.29707 == rgctx_type) goto <D.29708>; else goto <D.29709>;
    <D.29708>:
    D.29710 = otemplate->data;
    if (D.29710 == data) goto <D.29711>; else goto <D.29712>;
    <D.29711>:
    if (rgctx_type != 21) goto <D.29713>; else goto <D.29714>;
    <D.29713>:
    D.29715 = i;
    return D.29715;
    <D.29714>:
    <D.29712>:
    <D.29709>:
  }
  i = i + 1;
  <D.26198>:
  D.29702 = info->entries;
  D.29716 = D.29702->len;
  i.37 = (unsigned int) i;
  if (D.29716 > i.37) goto <D.26197>; else goto <D.26199>;
  <D.26199>:
  D.29718 = cfg->mempool;
  template = mono_mempool_alloc0 (D.29718, 24);
  template->info_type = rgctx_type;
  template->data = data;
  D.29702 = info->entries;
  D.29716 = D.29702->len;
  idx = (int) D.29716;
  D.29702 = info->entries;
  monoeg_g_ptr_array_add (D.29702, template);
  D.29715 = idx;
  return D.29715;
}


mini_class_check_context_used (struct MonoCompile * cfg, struct MonoClass * klass)
{
  struct MonoGenericSharingContext * D.29720;
  int D.29723;

  D.29720 = cfg->generic_sharing_context;
  if (D.29720 != 0B) goto <D.29721>; else goto <D.29722>;
  <D.29721>:
  D.29723 = mono_class_check_context_used (klass);
  return D.29723;
  <D.29722>:
  D.29723 = 0;
  return D.29723;
}


mono_emit_wb_aware_memcpy (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * * iargs, int size, int align)
{
  gboolean D.29729;
  struct MonoInst * * D.29734;
  struct MonoMemPool * D.29735;
  void * D.29736;
  struct MonoInst * D.29737;
  long int D.29738;
  struct MonoInst * D.29739;
  int D.29740;
  int D.29741;
  const unsigned char * D.29742;
  long int D.29743;
  unsigned int D.29744;
  int D.29745;
  struct MonoBasicBlock * D.29746;
  struct MonoInst * D.29747;
  struct MonoInst * D.29750;
  struct MonoInst * * D.29752;
  void * D.29753;
  struct MonoInst * D.29754;
  long int D.29755;
  struct MonoInst * D.29756;
  int D.29757;
  int D.29758;
  unsigned int need_wb.38;
  long int D.29760;
  unsigned int D.29761;
  int D.29762;
  struct MonoInst * D.29765;
  struct MonoInst * D.29767;
  struct MonoInst * * D.29768;
  struct MonoInst * D.29769;
  unsigned int D.29770;
  unsigned int D.29771;
  void * D.29772;
  long int D.29773;
  struct MonoInst * D.29774;
  int D.29775;
  int D.29776;
  long int D.29780;
  struct MonoInst * D.29781;
  int D.29782;
  int D.29783;
  long int D.29784;
  long int D.29788;
  struct MonoInst * D.29789;
  int D.29790;
  int D.29791;
  unsigned int D.29795;
  unsigned int need_wb.39;
  void * D.29801;
  long int D.29805;
  struct MonoInst * D.29806;
  int D.29807;
  int D.29808;
  long int D.29812;
  struct MonoInst * D.29813;
  int D.29814;
  int D.29815;
  long int D.29819;
  struct MonoInst * D.29820;
  int D.29821;
  int D.29822;
  long int D.29826;
  struct MonoInst * D.29827;
  int D.29828;
  int D.29829;
  long int D.29833;
  struct MonoInst * D.29834;
  int D.29835;
  int D.29836;
  long int D.29840;
  struct MonoInst * D.29841;
  int D.29842;
  int D.29843;
  int dest_ptr_reg;
  int tmp_reg;
  int destreg;
  int srcreg;
  int offset;
  unsigned int need_wb;

  try
    {
      need_wb = 0;
      if (align == 0) goto <D.29725>; else goto <D.29726>;
      <D.29725>:
      align = 4;
      <D.29726>:
      if (align <= 7) goto <D.29727>; else goto <D.29728>;
      <D.29727>:
      D.29729 = 0;
      return D.29729;
      <D.29728>:
      if (size > 256) goto <D.29730>; else goto <D.29731>;
      <D.29730>:
      D.29729 = 0;
      return D.29729;
      <D.29731>:
      create_write_barrier_bitmap (cfg, klass, &need_wb, 0);
      if (size > 40) goto <D.29732>; else goto <D.29733>;
      <D.29732>:
      size = size + 7;
      size = size & -8;
      D.29734 = iargs + 16;
      D.29735 = cfg->mempool;
      D.29736 = mono_mempool_alloc (D.29735, 80);
      *D.29734 = D.29736;
      D.29734 = iargs + 16;
      D.29737 = *D.29734;
      D.29734 = iargs + 16;
      D.29737 = *D.29734;
      D.29737->data.op[1].const_val = 0;
      D.29738 = D.29737->data.op[1].const_val;
      D.29737->data.op[0].const_val = D.29738;
      D.29734 = iargs + 16;
      D.29737 = *D.29734;
      D.29734 = iargs + 16;
      D.29737 = *D.29734;
      D.29737->prev = 0B;
      D.29739 = D.29737->prev;
      D.29737->next = D.29739;
      D.29734 = iargs + 16;
      D.29737 = *D.29734;
      D.29737->opcode = 362;
      D.29734 = iargs + 16;
      D.29737 = *D.29734;
      D.29737->flags = 0;
      D.29734 = iargs + 16;
      D.29737 = *D.29734;
      D.29737->type = 0;
      D.29734 = iargs + 16;
      D.29737 = *D.29734;
      D.29737->dreg = -1;
      D.29734 = iargs + 16;
      D.29737 = *D.29734;
      D.29734 = iargs + 16;
      D.29737 = *D.29734;
      D.29734 = iargs + 16;
      D.29737 = *D.29734;
      D.29737->sreg3 = -1;
      D.29740 = D.29737->sreg3;
      D.29737->sreg2 = D.29740;
      D.29741 = D.29737->sreg2;
      D.29737->sreg1 = D.29741;
      D.29734 = iargs + 16;
      D.29737 = *D.29734;
      D.29742 = cfg->ip;
      D.29737->cil_code = D.29742;
      D.29734 = iargs + 16;
      D.29737 = *D.29734;
      D.29743 = (long int) size;
      D.29737->data.op[0].const_val = D.29743;
      D.29734 = iargs + 16;
      D.29737 = *D.29734;
      D.29737->type = 1;
      D.29734 = iargs + 16;
      D.29737 = *D.29734;
      D.29744 = alloc_dreg (cfg, 1);
      D.29745 = (int) D.29744;
      D.29737->dreg = D.29745;
      D.29746 = cfg->cbb;
      D.29747 = D.29746->last_ins;
      if (D.29747 != 0B) goto <D.29748>; else goto <D.29749>;
      <D.29748>:
      D.29746 = cfg->cbb;
      D.29747 = D.29746->last_ins;
      D.29750 = MEM[(struct MonoInst * *)iargs + 16B];
      D.29747->next = D.29750;
      D.29734 = iargs + 16;
      D.29737 = *D.29734;
      D.29746 = cfg->cbb;
      D.29747 = D.29746->last_ins;
      D.29737->prev = D.29747;
      D.29746 = cfg->cbb;
      D.29750 = MEM[(struct MonoInst * *)iargs + 16B];
      D.29746->last_ins = D.29750;
      goto <D.29751>;
      <D.29749>:
      D.29746 = cfg->cbb;
      D.29746 = cfg->cbb;
      D.29750 = MEM[(struct MonoInst * *)iargs + 16B];
      D.29746->last_ins = D.29750;
      D.29747 = D.29746->last_ins;
      D.29746->code = D.29747;
      <D.29751>:
      D.29752 = iargs + 24;
      D.29735 = cfg->mempool;
      D.29753 = mono_mempool_alloc (D.29735, 80);
      *D.29752 = D.29753;
      D.29752 = iargs + 24;
      D.29754 = *D.29752;
      D.29752 = iargs + 24;
      D.29754 = *D.29752;
      D.29754->data.op[1].const_val = 0;
      D.29755 = D.29754->data.op[1].const_val;
      D.29754->data.op[0].const_val = D.29755;
      D.29752 = iargs + 24;
      D.29754 = *D.29752;
      D.29752 = iargs + 24;
      D.29754 = *D.29752;
      D.29754->prev = 0B;
      D.29756 = D.29754->prev;
      D.29754->next = D.29756;
      D.29752 = iargs + 24;
      D.29754 = *D.29752;
      D.29754->opcode = 362;
      D.29752 = iargs + 24;
      D.29754 = *D.29752;
      D.29754->flags = 0;
      D.29752 = iargs + 24;
      D.29754 = *D.29752;
      D.29754->type = 0;
      D.29752 = iargs + 24;
      D.29754 = *D.29752;
      D.29754->dreg = -1;
      D.29752 = iargs + 24;
      D.29754 = *D.29752;
      D.29752 = iargs + 24;
      D.29754 = *D.29752;
      D.29752 = iargs + 24;
      D.29754 = *D.29752;
      D.29754->sreg3 = -1;
      D.29757 = D.29754->sreg3;
      D.29754->sreg2 = D.29757;
      D.29758 = D.29754->sreg2;
      D.29754->sreg1 = D.29758;
      D.29752 = iargs + 24;
      D.29754 = *D.29752;
      D.29742 = cfg->ip;
      D.29754->cil_code = D.29742;
      D.29752 = iargs + 24;
      D.29754 = *D.29752;
      need_wb.38 = need_wb;
      D.29760 = (long int) need_wb.38;
      D.29754->data.op[0].const_val = D.29760;
      D.29752 = iargs + 24;
      D.29754 = *D.29752;
      D.29754->type = 1;
      D.29752 = iargs + 24;
      D.29754 = *D.29752;
      D.29761 = alloc_dreg (cfg, 1);
      D.29762 = (int) D.29761;
      D.29754->dreg = D.29762;
      D.29746 = cfg->cbb;
      D.29747 = D.29746->last_ins;
      if (D.29747 != 0B) goto <D.29763>; else goto <D.29764>;
      <D.29763>:
      D.29746 = cfg->cbb;
      D.29747 = D.29746->last_ins;
      D.29765 = MEM[(struct MonoInst * *)iargs + 24B];
      D.29747->next = D.29765;
      D.29752 = iargs + 24;
      D.29754 = *D.29752;
      D.29746 = cfg->cbb;
      D.29747 = D.29746->last_ins;
      D.29754->prev = D.29747;
      D.29746 = cfg->cbb;
      D.29765 = MEM[(struct MonoInst * *)iargs + 24B];
      D.29746->last_ins = D.29765;
      goto <D.29766>;
      <D.29764>:
      D.29746 = cfg->cbb;
      D.29746 = cfg->cbb;
      D.29765 = MEM[(struct MonoInst * *)iargs + 24B];
      D.29746->last_ins = D.29765;
      D.29747 = D.29746->last_ins;
      D.29746->code = D.29747;
      <D.29766>:
      mono_emit_jit_icall (cfg, mono_gc_wbarrier_value_copy_bitmap, iargs);
      D.29729 = 1;
      return D.29729;
      <D.29733>:
      D.29767 = *iargs;
      destreg = D.29767->dreg;
      D.29768 = iargs + 8;
      D.29769 = *D.29768;
      srcreg = D.29769->dreg;
      offset = 0;
      D.29770 = alloc_preg (cfg);
      dest_ptr_reg = (int) D.29770;
      D.29771 = alloc_preg (cfg);
      tmp_reg = (int) D.29771;
      D.29735 = cfg->mempool;
      D.29772 = mono_mempool_alloc (D.29735, 80);
      *iargs = D.29772;
      D.29767 = *iargs;
      D.29767 = *iargs;
      D.29767->data.op[1].const_val = 0;
      D.29773 = D.29767->data.op[1].const_val;
      D.29767->data.op[0].const_val = D.29773;
      D.29767 = *iargs;
      D.29767 = *iargs;
      D.29767->prev = 0B;
      D.29774 = D.29767->prev;
      D.29767->next = D.29774;
      D.29767 = *iargs;
      D.29767->opcode = 424;
      D.29767 = *iargs;
      D.29767->flags = 0;
      D.29767 = *iargs;
      D.29767->type = 0;
      D.29767 = *iargs;
      D.29767->dreg = -1;
      D.29767 = *iargs;
      D.29767 = *iargs;
      D.29767 = *iargs;
      D.29767->sreg3 = -1;
      D.29775 = D.29767->sreg3;
      D.29767->sreg2 = D.29775;
      D.29776 = D.29767->sreg2;
      D.29767->sreg1 = D.29776;
      D.29767 = *iargs;
      D.29742 = cfg->ip;
      D.29767->cil_code = D.29742;
      D.29767 = *iargs;
      D.29767->dreg = dest_ptr_reg;
      D.29767 = *iargs;
      D.29767->sreg1 = destreg;
      D.29746 = cfg->cbb;
      D.29747 = D.29746->last_ins;
      if (D.29747 != 0B) goto <D.29777>; else goto <D.29778>;
      <D.29777>:
      D.29746 = cfg->cbb;
      D.29747 = D.29746->last_ins;
      D.29767 = *iargs;
      D.29747->next = D.29767;
      D.29767 = *iargs;
      D.29746 = cfg->cbb;
      D.29747 = D.29746->last_ins;
      D.29767->prev = D.29747;
      D.29746 = cfg->cbb;
      D.29767 = *iargs;
      D.29746->last_ins = D.29767;
      goto <D.29779>;
      <D.29778>:
      D.29746 = cfg->cbb;
      D.29746 = cfg->cbb;
      D.29767 = *iargs;
      D.29746->last_ins = D.29767;
      D.29747 = D.29746->last_ins;
      D.29746->code = D.29747;
      <D.29779>:
      goto <D.26053>;
      <D.26052>:
      {
        struct MonoInst * load_inst;

        D.29735 = cfg->mempool;
        load_inst = mono_mempool_alloc (D.29735, 80);
        load_inst->data.op[1].const_val = 0;
        D.29780 = load_inst->data.op[1].const_val;
        load_inst->data.op[0].const_val = D.29780;
        load_inst->prev = 0B;
        D.29781 = load_inst->prev;
        load_inst->next = D.29781;
        load_inst->opcode = 388;
        load_inst->flags = 0;
        load_inst->type = 0;
        load_inst->dreg = -1;
        load_inst->sreg3 = -1;
        D.29782 = load_inst->sreg3;
        load_inst->sreg2 = D.29782;
        D.29783 = load_inst->sreg2;
        load_inst->sreg1 = D.29783;
        D.29742 = cfg->ip;
        load_inst->cil_code = D.29742;
        load_inst->dreg = tmp_reg;
        load_inst->sreg1 = srcreg;
        D.29784 = (long int) offset;
        load_inst->data.op[0].const_val = D.29784;
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        if (D.29747 != 0B) goto <D.29785>; else goto <D.29786>;
        <D.29785>:
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        D.29747->next = load_inst;
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        load_inst->prev = D.29747;
        D.29746 = cfg->cbb;
        D.29746->last_ins = load_inst;
        goto <D.29787>;
        <D.29786>:
        D.29746 = cfg->cbb;
        D.29746 = cfg->cbb;
        D.29746->last_ins = load_inst;
        D.29747 = D.29746->last_ins;
        D.29746->code = D.29747;
        <D.29787>:
        {
          struct MonoInst * inst;

          D.29735 = cfg->mempool;
          inst = mono_mempool_alloc (D.29735, 80);
          inst->data.op[1].const_val = 0;
          D.29788 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29788;
          inst->prev = 0B;
          D.29789 = inst->prev;
          inst->next = D.29789;
          inst->opcode = 378;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29790 = inst->sreg3;
          inst->sreg2 = D.29790;
          D.29791 = inst->sreg2;
          inst->sreg1 = D.29791;
          D.29742 = cfg->ip;
          inst->cil_code = D.29742;
          inst->sreg1 = tmp_reg;
          inst->dreg = dest_ptr_reg;
          inst->data.op[0].const_val = 0;
          D.29746 = cfg->cbb;
          D.29747 = D.29746->last_ins;
          if (D.29747 != 0B) goto <D.29792>; else goto <D.29793>;
          <D.29792>:
          D.29746 = cfg->cbb;
          D.29747 = D.29746->last_ins;
          D.29747->next = inst;
          D.29746 = cfg->cbb;
          D.29747 = D.29746->last_ins;
          inst->prev = D.29747;
          D.29746 = cfg->cbb;
          D.29746->last_ins = inst;
          goto <D.29794>;
          <D.29793>:
          D.29746 = cfg->cbb;
          D.29746 = cfg->cbb;
          D.29746->last_ins = inst;
          D.29747 = D.29746->last_ins;
          D.29746->code = D.29747;
          <D.29794>:
        }
        need_wb.38 = need_wb;
        D.29795 = need_wb.38 & 1;
        if (D.29795 != 0) goto <D.29796>; else goto <D.29797>;
        <D.29796>:
        D.29767 = *iargs;
        emit_write_barrier (cfg, D.29767, load_inst);
        <D.29797>:
        offset = offset + 8;
        size = size + -8;
        need_wb.38 = need_wb;
        need_wb.39 = need_wb.38 >> 1;
        need_wb = need_wb.39;
        if (size > 7) goto <D.29799>; else goto <D.29800>;
        <D.29799>:
        D.29735 = cfg->mempool;
        D.29801 = mono_mempool_alloc (D.29735, 80);
        *iargs = D.29801;
        D.29767 = *iargs;
        D.29767 = *iargs;
        D.29767->data.op[1].const_val = 0;
        D.29773 = D.29767->data.op[1].const_val;
        D.29767->data.op[0].const_val = D.29773;
        D.29767 = *iargs;
        D.29767 = *iargs;
        D.29767->prev = 0B;
        D.29774 = D.29767->prev;
        D.29767->next = D.29774;
        D.29767 = *iargs;
        D.29767->opcode = 538;
        D.29767 = *iargs;
        D.29767->flags = 0;
        D.29767 = *iargs;
        D.29767->type = 0;
        D.29767 = *iargs;
        D.29767->dreg = -1;
        D.29767 = *iargs;
        D.29767 = *iargs;
        D.29767 = *iargs;
        D.29767->sreg3 = -1;
        D.29775 = D.29767->sreg3;
        D.29767->sreg2 = D.29775;
        D.29776 = D.29767->sreg2;
        D.29767->sreg1 = D.29776;
        D.29767 = *iargs;
        D.29742 = cfg->ip;
        D.29767->cil_code = D.29742;
        D.29767 = *iargs;
        D.29767->dreg = dest_ptr_reg;
        D.29767 = *iargs;
        D.29767->sreg1 = dest_ptr_reg;
        D.29767 = *iargs;
        D.29767->data.op[1].const_val = 8;
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        if (D.29747 != 0B) goto <D.29802>; else goto <D.29803>;
        <D.29802>:
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        D.29767 = *iargs;
        D.29747->next = D.29767;
        D.29767 = *iargs;
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        D.29767->prev = D.29747;
        D.29746 = cfg->cbb;
        D.29767 = *iargs;
        D.29746->last_ins = D.29767;
        goto <D.29804>;
        <D.29803>:
        D.29746 = cfg->cbb;
        D.29746 = cfg->cbb;
        D.29767 = *iargs;
        D.29746->last_ins = D.29767;
        D.29747 = D.29746->last_ins;
        D.29746->code = D.29747;
        <D.29804>:
        <D.29800>:
      }
      <D.26053>:
      if (size > 7) goto <D.26052>; else goto <D.26054>;
      <D.26054>:
      goto <D.26058>;
      <D.26057>:
      {
        struct MonoInst * inst;

        D.29735 = cfg->mempool;
        inst = mono_mempool_alloc (D.29735, 80);
        inst->data.op[1].const_val = 0;
        D.29805 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.29805;
        inst->prev = 0B;
        D.29806 = inst->prev;
        inst->next = D.29806;
        inst->opcode = 393;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.29807 = inst->sreg3;
        inst->sreg2 = D.29807;
        D.29808 = inst->sreg2;
        inst->sreg1 = D.29808;
        D.29742 = cfg->ip;
        inst->cil_code = D.29742;
        inst->dreg = tmp_reg;
        inst->sreg1 = srcreg;
        D.29784 = (long int) offset;
        inst->data.op[0].const_val = D.29784;
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        if (D.29747 != 0B) goto <D.29809>; else goto <D.29810>;
        <D.29809>:
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        D.29747->next = inst;
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        inst->prev = D.29747;
        D.29746 = cfg->cbb;
        D.29746->last_ins = inst;
        goto <D.29811>;
        <D.29810>:
        D.29746 = cfg->cbb;
        D.29746 = cfg->cbb;
        D.29746->last_ins = inst;
        D.29747 = D.29746->last_ins;
        D.29746->code = D.29747;
        <D.29811>:
      }
      {
        struct MonoInst * inst;

        D.29735 = cfg->mempool;
        inst = mono_mempool_alloc (D.29735, 80);
        inst->data.op[1].const_val = 0;
        D.29812 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.29812;
        inst->prev = 0B;
        D.29813 = inst->prev;
        inst->next = D.29813;
        inst->opcode = 377;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.29814 = inst->sreg3;
        inst->sreg2 = D.29814;
        D.29815 = inst->sreg2;
        inst->sreg1 = D.29815;
        D.29742 = cfg->ip;
        inst->cil_code = D.29742;
        inst->sreg1 = tmp_reg;
        inst->dreg = destreg;
        D.29784 = (long int) offset;
        inst->data.op[0].const_val = D.29784;
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        if (D.29747 != 0B) goto <D.29816>; else goto <D.29817>;
        <D.29816>:
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        D.29747->next = inst;
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        inst->prev = D.29747;
        D.29746 = cfg->cbb;
        D.29746->last_ins = inst;
        goto <D.29818>;
        <D.29817>:
        D.29746 = cfg->cbb;
        D.29746 = cfg->cbb;
        D.29746->last_ins = inst;
        D.29747 = D.29746->last_ins;
        D.29746->code = D.29747;
        <D.29818>:
      }
      offset = offset + 4;
      size = size + -4;
      <D.26058>:
      if (size > 3) goto <D.26057>; else goto <D.26059>;
      <D.26059>:
      goto <D.26063>;
      <D.26062>:
      {
        struct MonoInst * inst;

        D.29735 = cfg->mempool;
        inst = mono_mempool_alloc (D.29735, 80);
        inst->data.op[1].const_val = 0;
        D.29819 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.29819;
        inst->prev = 0B;
        D.29820 = inst->prev;
        inst->next = D.29820;
        inst->opcode = 391;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.29821 = inst->sreg3;
        inst->sreg2 = D.29821;
        D.29822 = inst->sreg2;
        inst->sreg1 = D.29822;
        D.29742 = cfg->ip;
        inst->cil_code = D.29742;
        inst->dreg = tmp_reg;
        inst->sreg1 = srcreg;
        D.29784 = (long int) offset;
        inst->data.op[0].const_val = D.29784;
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        if (D.29747 != 0B) goto <D.29823>; else goto <D.29824>;
        <D.29823>:
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        D.29747->next = inst;
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        inst->prev = D.29747;
        D.29746 = cfg->cbb;
        D.29746->last_ins = inst;
        goto <D.29825>;
        <D.29824>:
        D.29746 = cfg->cbb;
        D.29746 = cfg->cbb;
        D.29746->last_ins = inst;
        D.29747 = D.29746->last_ins;
        D.29746->code = D.29747;
        <D.29825>:
      }
      {
        struct MonoInst * inst;

        D.29735 = cfg->mempool;
        inst = mono_mempool_alloc (D.29735, 80);
        inst->data.op[1].const_val = 0;
        D.29826 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.29826;
        inst->prev = 0B;
        D.29827 = inst->prev;
        inst->next = D.29827;
        inst->opcode = 376;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.29828 = inst->sreg3;
        inst->sreg2 = D.29828;
        D.29829 = inst->sreg2;
        inst->sreg1 = D.29829;
        D.29742 = cfg->ip;
        inst->cil_code = D.29742;
        inst->sreg1 = tmp_reg;
        inst->dreg = destreg;
        D.29784 = (long int) offset;
        inst->data.op[0].const_val = D.29784;
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        if (D.29747 != 0B) goto <D.29830>; else goto <D.29831>;
        <D.29830>:
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        D.29747->next = inst;
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        inst->prev = D.29747;
        D.29746 = cfg->cbb;
        D.29746->last_ins = inst;
        goto <D.29832>;
        <D.29831>:
        D.29746 = cfg->cbb;
        D.29746 = cfg->cbb;
        D.29746->last_ins = inst;
        D.29747 = D.29746->last_ins;
        D.29746->code = D.29747;
        <D.29832>:
      }
      offset = offset + 2;
      size = size + -2;
      <D.26063>:
      if (size > 1) goto <D.26062>; else goto <D.26064>;
      <D.26064>:
      goto <D.26068>;
      <D.26067>:
      {
        struct MonoInst * inst;

        D.29735 = cfg->mempool;
        inst = mono_mempool_alloc (D.29735, 80);
        inst->data.op[1].const_val = 0;
        D.29833 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.29833;
        inst->prev = 0B;
        D.29834 = inst->prev;
        inst->next = D.29834;
        inst->opcode = 389;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.29835 = inst->sreg3;
        inst->sreg2 = D.29835;
        D.29836 = inst->sreg2;
        inst->sreg1 = D.29836;
        D.29742 = cfg->ip;
        inst->cil_code = D.29742;
        inst->dreg = tmp_reg;
        inst->sreg1 = srcreg;
        D.29784 = (long int) offset;
        inst->data.op[0].const_val = D.29784;
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        if (D.29747 != 0B) goto <D.29837>; else goto <D.29838>;
        <D.29837>:
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        D.29747->next = inst;
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        inst->prev = D.29747;
        D.29746 = cfg->cbb;
        D.29746->last_ins = inst;
        goto <D.29839>;
        <D.29838>:
        D.29746 = cfg->cbb;
        D.29746 = cfg->cbb;
        D.29746->last_ins = inst;
        D.29747 = D.29746->last_ins;
        D.29746->code = D.29747;
        <D.29839>:
      }
      {
        struct MonoInst * inst;

        D.29735 = cfg->mempool;
        inst = mono_mempool_alloc (D.29735, 80);
        inst->data.op[1].const_val = 0;
        D.29840 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.29840;
        inst->prev = 0B;
        D.29841 = inst->prev;
        inst->next = D.29841;
        inst->opcode = 375;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.29842 = inst->sreg3;
        inst->sreg2 = D.29842;
        D.29843 = inst->sreg2;
        inst->sreg1 = D.29843;
        D.29742 = cfg->ip;
        inst->cil_code = D.29742;
        inst->sreg1 = tmp_reg;
        inst->dreg = destreg;
        D.29784 = (long int) offset;
        inst->data.op[0].const_val = D.29784;
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        if (D.29747 != 0B) goto <D.29844>; else goto <D.29845>;
        <D.29844>:
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        D.29747->next = inst;
        D.29746 = cfg->cbb;
        D.29747 = D.29746->last_ins;
        inst->prev = D.29747;
        D.29746 = cfg->cbb;
        D.29746->last_ins = inst;
        goto <D.29846>;
        <D.29845>:
        D.29746 = cfg->cbb;
        D.29746 = cfg->cbb;
        D.29746->last_ins = inst;
        D.29747 = D.29746->last_ins;
        D.29746->code = D.29747;
        <D.29846>:
      }
      offset = offset + 1;
      size = size + -1;
      <D.26068>:
      if (size > 0) goto <D.26067>; else goto <D.26069>;
      <D.26069>:
      D.29729 = 1;
      return D.29729;
    }
  finally
    {
      need_wb = {CLOBBER};
    }
}


create_write_barrier_bitmap (struct MonoCompile * cfg, struct MonoClass * klass, unsigned int * wb_bitmap, int offset)
{
  struct MonoType * D.29849;
  short unsigned int D.29850;
  int D.29851;
  int D.29852;
  int iftmp.40;
  long unsigned int D.29856;
  long unsigned int D.29857;
  int D.29860;
  unsigned int D.29861;
  unsigned int D.29862;
  struct MonoType * D.29864;
  int D.29865;
  unsigned int foffset.41;
  unsigned int D.29869;
  _Bool D.29870;
  long int D.29871;
  long int D.29872;
  unsigned int D.29875;
  int D.29876;
  int D.29877;
  int D.29878;
  unsigned int D.29879;
  unsigned int D.29880;
  long unsigned int D.29882;
  long unsigned int D.29883;
  struct MonoClassField * field;
  void * iter;

  try
    {
      iter = 0B;
      goto <D.26011>;
      <D.26013>:
      {
        int foffset;

        D.29849 = field->type;
        D.29850 = D.29849->attrs;
        D.29851 = (int) D.29850;
        D.29852 = D.29851 & 16;
        if (D.29852 != 0) goto <D.29853>; else goto <D.29854>;
        <D.29853>:
        // predicted unlikely by continue predictor.
        goto <D.26011>;
        <D.29854>:
        D.29856 = BIT_FIELD_REF <*klass, 64, 256>;
        D.29857 = D.29856 & 1152921504606846976;
        if (D.29857 != 0) goto <D.29858>; else goto <D.29859>;
        <D.29858>:
        D.29860 = field->offset;
        D.29861 = (unsigned int) D.29860;
        D.29862 = D.29861 + 4294967280;
        iftmp.40 = (int) D.29862;
        goto <D.29863>;
        <D.29859>:
        iftmp.40 = field->offset;
        <D.29863>:
        foffset = iftmp.40;
        D.29864 = mono_field_get_type (field);
        D.29865 = mini_type_is_reference (cfg, D.29864);
        if (D.29865 != 0) goto <D.29866>; else goto <D.29867>;
        <D.29866>:
        foffset.41 = (unsigned int) foffset;
        D.29869 = foffset.41 & 7;
        D.29870 = D.29869 != 0;
        D.29871 = (long int) D.29870;
        D.29872 = __builtin_expect (D.29871, 0);
        if (D.29872 != 0) goto <D.29873>; else goto <D.29874>;
        <D.29873>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 2886, "(foffset % SIZEOF_VOID_P) == 0");
        <D.29874>:
        D.29875 = *wb_bitmap;
        D.29876 = offset + foffset;
        D.29877 = D.29876 / 8;
        D.29878 = 1 << D.29877;
        D.29879 = (unsigned int) D.29878;
        D.29880 = D.29875 | D.29879;
        *wb_bitmap = D.29880;
        goto <D.29881>;
        <D.29867>:
        {
          struct MonoClass * field_class;

          D.29849 = field->type;
          field_class = mono_class_from_mono_type (D.29849);
          D.29882 = BIT_FIELD_REF <*field_class, 64, 256>;
          D.29883 = D.29882 & 68719476736;
          if (D.29883 != 0) goto <D.29884>; else goto <D.29885>;
          <D.29884>:
          D.29876 = offset + foffset;
          create_write_barrier_bitmap (cfg, field_class, wb_bitmap, D.29876);
          <D.29885>:
        }
        <D.29881>:
      }
      <D.26011>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.26013>; else goto <D.26014>;
      <D.26014>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


emit_write_barrier (struct MonoCompile * cfg, struct MonoInst * ptr, struct MonoInst * value)
{
  long unsigned int D.29886;
  long unsigned int D.29887;
  long unsigned int D.29893;
  int nursery_shift_bits.42;
  struct MonoMemPool * D.29898;
  long int D.29899;
  struct MonoInst * D.29900;
  int D.29901;
  int D.29902;
  const unsigned char * D.29903;
  struct MonoInst * ptr.43;
  int D.29905;
  int D.29906;
  struct MonoBasicBlock * D.29907;
  struct MonoInst * D.29908;
  unsigned int D.29914;
  unsigned int D.29915;
  long int D.29916;
  struct MonoInst * D.29917;
  int D.29918;
  int D.29919;
  int card_table_shift_bits.44;
  long int D.29921;
  void * card_table_mask.45;
  long int D.29928;
  struct MonoInst * D.29929;
  int D.29930;
  int D.29931;
  long int card_table_mask.46;
  long int D.29938;
  struct MonoInst * D.29939;
  guint16 iftmp.47;
  int D.29944;
  int D.29945;
  long int D.29950;
  struct MonoInst * D.29951;
  int D.29952;
  int D.29953;
  long int D.29957;
  struct MonoInst * D.29958;
  int D.29959;
  int D.29960;
  long int D.29964;
  struct MonoInst * D.29965;
  int D.29966;
  int D.29967;
  long int D.29972;
  struct MonoInst * D.29973;
  int D.29974;
  int D.29975;
  int card_table_shift_bits;
  void * card_table_mask;
  guint8 * card_table;
  struct MonoInst * dummy_use;
  int nursery_shift_bits;
  size_t nursery_size;
  gboolean has_card_table_wb;

  try
    {
      has_card_table_wb = 0;
      D.29886 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29887 = D.29886 & 8;
      if (D.29887 == 0) goto <D.29888>; else goto <D.29889>;
      <D.29888>:
      return;
      <D.29889>:
      card_table = mono_gc_get_card_table (&card_table_shift_bits, &card_table_mask);
      mono_gc_get_nursery (&nursery_shift_bits, &nursery_size);
      if (has_card_table_wb != 0) goto <D.29892>; else goto <D.29890>;
      <D.29892>:
      D.29886 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.29893 = D.29886 & 33554432;
      if (D.29893 == 0) goto <D.29894>; else goto <D.29890>;
      <D.29894>:
      if (card_table != 0B) goto <D.29895>; else goto <D.29890>;
      <D.29895>:
      nursery_shift_bits.42 = nursery_shift_bits;
      if (nursery_shift_bits.42 > 0) goto <D.29897>; else goto <D.29890>;
      <D.29897>:
      {
        struct MonoInst * wbarrier;

        D.29898 = cfg->mempool;
        wbarrier = mono_mempool_alloc (D.29898, 80);
        wbarrier->data.op[1].const_val = 0;
        D.29899 = wbarrier->data.op[1].const_val;
        wbarrier->data.op[0].const_val = D.29899;
        wbarrier->prev = 0B;
        D.29900 = wbarrier->prev;
        wbarrier->next = D.29900;
        wbarrier->opcode = 790;
        wbarrier->flags = 0;
        wbarrier->type = 0;
        wbarrier->dreg = -1;
        wbarrier->sreg3 = -1;
        D.29901 = wbarrier->sreg3;
        wbarrier->sreg2 = D.29901;
        D.29902 = wbarrier->sreg2;
        wbarrier->sreg1 = D.29902;
        D.29903 = cfg->ip;
        wbarrier->cil_code = D.29903;
        ptr.43 = ptr;
        D.29905 = ptr.43->dreg;
        wbarrier->sreg1 = D.29905;
        D.29906 = value->dreg;
        wbarrier->sreg2 = D.29906;
        D.29907 = cfg->cbb;
        D.29908 = D.29907->last_ins;
        if (D.29908 != 0B) goto <D.29909>; else goto <D.29910>;
        <D.29909>:
        D.29907 = cfg->cbb;
        D.29908 = D.29907->last_ins;
        D.29908->next = wbarrier;
        D.29907 = cfg->cbb;
        D.29908 = D.29907->last_ins;
        wbarrier->prev = D.29908;
        D.29907 = cfg->cbb;
        D.29907->last_ins = wbarrier;
        goto <D.29911>;
        <D.29910>:
        D.29907 = cfg->cbb;
        D.29907 = cfg->cbb;
        D.29907->last_ins = wbarrier;
        D.29908 = D.29907->last_ins;
        D.29907->code = D.29908;
        <D.29911>:
      }
      goto <D.29891>;
      <D.29890>:
      if (card_table != 0B) goto <D.29912>; else goto <D.29913>;
      <D.29912>:
      {
        int offset_reg;
        int card_reg;
        struct MonoInst * ins;

        D.29914 = alloc_preg (cfg);
        offset_reg = (int) D.29914;
        D.29915 = alloc_preg (cfg);
        card_reg = (int) D.29915;
        {
          struct MonoInst * inst;

          D.29898 = cfg->mempool;
          inst = mono_mempool_alloc (D.29898, 80);
          inst->data.op[1].const_val = 0;
          D.29916 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29916;
          inst->prev = 0B;
          D.29917 = inst->prev;
          inst->next = D.29917;
          inst->opcode = 441;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29918 = inst->sreg3;
          inst->sreg2 = D.29918;
          D.29919 = inst->sreg2;
          inst->sreg1 = D.29919;
          D.29903 = cfg->ip;
          inst->cil_code = D.29903;
          inst->dreg = offset_reg;
          ptr.43 = ptr;
          D.29905 = ptr.43->dreg;
          inst->sreg1 = D.29905;
          card_table_shift_bits.44 = card_table_shift_bits;
          D.29921 = (long int) card_table_shift_bits.44;
          inst->data.op[1].const_val = D.29921;
          D.29907 = cfg->cbb;
          D.29908 = D.29907->last_ins;
          if (D.29908 != 0B) goto <D.29922>; else goto <D.29923>;
          <D.29922>:
          D.29907 = cfg->cbb;
          D.29908 = D.29907->last_ins;
          D.29908->next = inst;
          D.29907 = cfg->cbb;
          D.29908 = D.29907->last_ins;
          inst->prev = D.29908;
          D.29907 = cfg->cbb;
          D.29907->last_ins = inst;
          goto <D.29924>;
          <D.29923>:
          D.29907 = cfg->cbb;
          D.29907 = cfg->cbb;
          D.29907->last_ins = inst;
          D.29908 = D.29907->last_ins;
          D.29907->code = D.29908;
          <D.29924>:
        }
        card_table_mask.45 = card_table_mask;
        if (card_table_mask.45 != 0B) goto <D.29926>; else goto <D.29927>;
        <D.29926>:
        {
          struct MonoInst * inst;

          D.29898 = cfg->mempool;
          inst = mono_mempool_alloc (D.29898, 80);
          inst->data.op[1].const_val = 0;
          D.29928 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29928;
          inst->prev = 0B;
          D.29929 = inst->prev;
          inst->next = D.29929;
          inst->opcode = 541;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29930 = inst->sreg3;
          inst->sreg2 = D.29930;
          D.29931 = inst->sreg2;
          inst->sreg1 = D.29931;
          D.29903 = cfg->ip;
          inst->cil_code = D.29903;
          inst->dreg = offset_reg;
          inst->sreg1 = offset_reg;
          card_table_mask.45 = card_table_mask;
          card_table_mask.46 = (long int) card_table_mask.45;
          inst->data.op[1].const_val = card_table_mask.46;
          D.29907 = cfg->cbb;
          D.29908 = D.29907->last_ins;
          if (D.29908 != 0B) goto <D.29933>; else goto <D.29934>;
          <D.29933>:
          D.29907 = cfg->cbb;
          D.29908 = D.29907->last_ins;
          D.29908->next = inst;
          D.29907 = cfg->cbb;
          D.29908 = D.29907->last_ins;
          inst->prev = D.29908;
          D.29907 = cfg->cbb;
          D.29907->last_ins = inst;
          goto <D.29935>;
          <D.29934>:
          D.29907 = cfg->cbb;
          D.29907 = cfg->cbb;
          D.29907->last_ins = inst;
          D.29908 = D.29907->last_ins;
          D.29907->code = D.29908;
          <D.29935>:
        }
        <D.29927>:
        D.29886 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.29893 = D.29886 & 33554432;
        if (D.29893 != 0) goto <D.29936>; else goto <D.29937>;
        <D.29936>:
        {
          struct MonoInst * inst;

          D.29898 = cfg->mempool;
          inst = mono_mempool_alloc (D.29898, 80);
          inst->data.op[1].const_val = 0;
          D.29938 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29938;
          inst->prev = 0B;
          D.29939 = inst->prev;
          inst->next = D.29939;
          D.29886 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.29893 = D.29886 & 33554432;
          if (D.29893 != 0) goto <D.29941>; else goto <D.29942>;
          <D.29941>:
          iftmp.47 = 732;
          goto <D.29943>;
          <D.29942>:
          iftmp.47 = 363;
          <D.29943>:
          inst->opcode = iftmp.47;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29944 = inst->sreg3;
          inst->sreg2 = D.29944;
          D.29945 = inst->sreg2;
          inst->sreg1 = D.29945;
          D.29903 = cfg->ip;
          inst->cil_code = D.29903;
          inst->dreg = card_reg;
          inst->data.op[0].p = 0B;
          inst->data.op[1].const_val = 42;
          D.29907 = cfg->cbb;
          D.29908 = D.29907->last_ins;
          if (D.29908 != 0B) goto <D.29946>; else goto <D.29947>;
          <D.29946>:
          D.29907 = cfg->cbb;
          D.29908 = D.29907->last_ins;
          D.29908->next = inst;
          D.29907 = cfg->cbb;
          D.29908 = D.29907->last_ins;
          inst->prev = D.29908;
          D.29907 = cfg->cbb;
          D.29907->last_ins = inst;
          goto <D.29948>;
          <D.29947>:
          D.29907 = cfg->cbb;
          D.29907 = cfg->cbb;
          D.29907->last_ins = inst;
          D.29908 = D.29907->last_ins;
          D.29907->code = D.29908;
          <D.29948>:
        }
        goto <D.29949>;
        <D.29937>:
        D.29898 = cfg->mempool;
        ins = mono_mempool_alloc (D.29898, 80);
        ins->data.op[1].const_val = 0;
        D.29950 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.29950;
        ins->prev = 0B;
        D.29951 = ins->prev;
        ins->next = D.29951;
        ins->opcode = 363;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.29952 = ins->sreg3;
        ins->sreg2 = D.29952;
        D.29953 = ins->sreg2;
        ins->sreg1 = D.29953;
        D.29903 = cfg->ip;
        ins->cil_code = D.29903;
        ins->data.op[0].p = card_table;
        ins->dreg = card_reg;
        D.29907 = cfg->cbb;
        D.29908 = D.29907->last_ins;
        if (D.29908 != 0B) goto <D.29954>; else goto <D.29955>;
        <D.29954>:
        D.29907 = cfg->cbb;
        D.29908 = D.29907->last_ins;
        D.29908->next = ins;
        D.29907 = cfg->cbb;
        D.29908 = D.29907->last_ins;
        ins->prev = D.29908;
        D.29907 = cfg->cbb;
        D.29907->last_ins = ins;
        goto <D.29956>;
        <D.29955>:
        D.29907 = cfg->cbb;
        D.29907 = cfg->cbb;
        D.29907->last_ins = ins;
        D.29908 = D.29907->last_ins;
        D.29907->code = D.29908;
        <D.29956>:
        <D.29949>:
        {
          struct MonoInst * inst;

          D.29898 = cfg->mempool;
          inst = mono_mempool_alloc (D.29898, 80);
          inst->data.op[1].const_val = 0;
          D.29957 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29957;
          inst->prev = 0B;
          D.29958 = inst->prev;
          inst->next = D.29958;
          inst->opcode = 479;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29959 = inst->sreg3;
          inst->sreg2 = D.29959;
          D.29960 = inst->sreg2;
          inst->sreg1 = D.29960;
          D.29903 = cfg->ip;
          inst->cil_code = D.29903;
          inst->dreg = offset_reg;
          inst->sreg1 = offset_reg;
          inst->sreg2 = card_reg;
          D.29907 = cfg->cbb;
          D.29908 = D.29907->last_ins;
          if (D.29908 != 0B) goto <D.29961>; else goto <D.29962>;
          <D.29961>:
          D.29907 = cfg->cbb;
          D.29908 = D.29907->last_ins;
          D.29908->next = inst;
          D.29907 = cfg->cbb;
          D.29908 = D.29907->last_ins;
          inst->prev = D.29908;
          D.29907 = cfg->cbb;
          D.29907->last_ins = inst;
          goto <D.29963>;
          <D.29962>:
          D.29907 = cfg->cbb;
          D.29907 = cfg->cbb;
          D.29907->last_ins = inst;
          D.29908 = D.29907->last_ins;
          D.29907->code = D.29908;
          <D.29963>:
        }
        {
          struct MonoInst * inst;

          D.29898 = cfg->mempool;
          inst = mono_mempool_alloc (D.29898, 80);
          inst->data.op[1].const_val = 0;
          D.29964 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.29964;
          inst->prev = 0B;
          D.29965 = inst->prev;
          inst->next = D.29965;
          inst->opcode = 382;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.29966 = inst->sreg3;
          inst->sreg2 = D.29966;
          D.29967 = inst->sreg2;
          inst->sreg1 = D.29967;
          D.29903 = cfg->ip;
          inst->cil_code = D.29903;
          inst->dreg = offset_reg;
          inst->data.op[0].const_val = 0;
          inst->data.op[1].const_val = 1;
          D.29907 = cfg->cbb;
          D.29908 = D.29907->last_ins;
          if (D.29908 != 0B) goto <D.29968>; else goto <D.29969>;
          <D.29968>:
          D.29907 = cfg->cbb;
          D.29908 = D.29907->last_ins;
          D.29908->next = inst;
          D.29907 = cfg->cbb;
          D.29908 = D.29907->last_ins;
          inst->prev = D.29908;
          D.29907 = cfg->cbb;
          D.29907->last_ins = inst;
          goto <D.29970>;
          <D.29969>:
          D.29907 = cfg->cbb;
          D.29907 = cfg->cbb;
          D.29907->last_ins = inst;
          D.29908 = D.29907->last_ins;
          D.29907->code = D.29908;
          <D.29970>:
        }
      }
      goto <D.29971>;
      <D.29913>:
      {
        struct MonoMethod * write_barrier;

        write_barrier = mono_gc_get_write_barrier ();
        mono_emit_method_call (cfg, write_barrier, &ptr, 0B);
      }
      <D.29971>:
      <D.29891>:
      D.29898 = cfg->mempool;
      dummy_use = mono_mempool_alloc (D.29898, 80);
      dummy_use->data.op[1].const_val = 0;
      D.29972 = dummy_use->data.op[1].const_val;
      dummy_use->data.op[0].const_val = D.29972;
      dummy_use->prev = 0B;
      D.29973 = dummy_use->prev;
      dummy_use->next = D.29973;
      dummy_use->opcode = 796;
      dummy_use->flags = 0;
      dummy_use->type = 0;
      dummy_use->dreg = -1;
      dummy_use->sreg3 = -1;
      D.29974 = dummy_use->sreg3;
      dummy_use->sreg2 = D.29974;
      D.29975 = dummy_use->sreg2;
      dummy_use->sreg1 = D.29975;
      D.29903 = cfg->ip;
      dummy_use->cil_code = D.29903;
      D.29906 = value->dreg;
      dummy_use->sreg1 = D.29906;
      D.29907 = cfg->cbb;
      D.29908 = D.29907->last_ins;
      if (D.29908 != 0B) goto <D.29976>; else goto <D.29977>;
      <D.29976>:
      D.29907 = cfg->cbb;
      D.29908 = D.29907->last_ins;
      D.29908->next = dummy_use;
      D.29907 = cfg->cbb;
      D.29908 = D.29907->last_ins;
      dummy_use->prev = D.29908;
      D.29907 = cfg->cbb;
      D.29907->last_ins = dummy_use;
      goto <D.29978>;
      <D.29977>:
      D.29907 = cfg->cbb;
      D.29907 = cfg->cbb;
      D.29907->last_ins = dummy_use;
      D.29908 = D.29907->last_ins;
      D.29907->code = D.29908;
      <D.29978>:
    }
  finally
    {
      card_table_shift_bits = {CLOBBER};
      card_table_mask = {CLOBBER};
      nursery_shift_bits = {CLOBBER};
      nursery_size = {CLOBBER};
    }
}


emit_get_rgctx_klass (struct MonoCompile * cfg, int context_used, struct MonoClass * klass, MonoRgctxInfoType rgctx_type)
{
  struct MonoMemPool * D.29982;
  struct MonoMethod * D.29983;
  int D.29984;
  struct MonoInst * D.29985;
  struct MonoJumpInfoRgctxEntry * entry;
  struct MonoInst * rgctx;

  D.29982 = cfg->mempool;
  D.29983 = cfg->current_method;
  D.29984 = context_used & 2;
  entry = mono_patch_info_rgctx_entry_new (D.29982, D.29983, D.29984, 11, klass, rgctx_type);
  D.29983 = cfg->current_method;
  rgctx = emit_get_rgctx (cfg, D.29983, context_used);
  D.29985 = emit_rgctx_fetch (cfg, rgctx, entry);
  return D.29985;
}


get_memcpy_method ()
{
  struct MonoMethod * memcpy_method.48;
  struct MonoClass * D.29990;
  struct MonoMethod * memcpy_method.49;
  struct MonoMethod * D.29994;
  static struct MonoMethod * memcpy_method = 0B;

  memcpy_method.48 = memcpy_method;
  if (memcpy_method.48 == 0B) goto <D.29988>; else goto <D.29989>;
  <D.29988>:
  D.29990 = mono_defaults.string_class;
  memcpy_method.49 = mono_class_get_method_from_name (D.29990, "memcpy", 3);
  memcpy_method = memcpy_method.49;
  memcpy_method.48 = memcpy_method;
  if (memcpy_method.48 == 0B) goto <D.29992>; else goto <D.29993>;
  <D.29992>:
  monoeg_g_log (0B, 4, "Old corlib found. Install a new one");
  <D.26001>:
  goto <D.26001>;
  <D.29993>:
  <D.29989>:
  D.29994 = memcpy_method;
  return D.29994;
}


__attribute__((visibility ("hidden")))
mini_emit_initobj (struct MonoCompile * cfg, struct MonoInst * dest, const guchar * ip, struct MonoClass * klass)
{
  int D.29996;
  struct MonoMethod * bzero_method.50;
  struct MonoClass * D.30002;
  struct MonoMethod * bzero_method.51;
  _Bool D.30004;
  long int D.30005;
  long int D.30006;
  struct MonoMethodSignature * D.30009;
  unsigned int n.52;
  int D.30013;
  unsigned int align.53;
  int align.54;
  struct MonoMemPool * D.30017;
  void * D.30018;
  struct MonoInst * D.30019;
  long int D.30020;
  struct MonoInst * D.30021;
  int D.30022;
  int D.30023;
  const unsigned char * D.30024;
  unsigned int D.30025;
  int D.30026;
  struct MonoBasicBlock * D.30027;
  struct MonoInst * D.30028;
  void * D.30032;
  struct MonoInst * D.30033;
  long int D.30034;
  struct MonoInst * D.30035;
  int D.30036;
  int D.30037;
  long int D.30038;
  unsigned int D.30039;
  int D.30040;
  struct MonoInst * iargs[3];
  int n;
  int context_used;
  guint32 align;
  struct MonoMethod * memset_method;
  struct MonoInst * size_ins;
  struct MonoInst * bzero_ins;
  static struct MonoMethod * bzero_method;

  try
    {
      size_ins = 0B;
      bzero_ins = 0B;
      mono_class_init (klass);
      D.29996 = mini_is_gsharedvt_klass (cfg, klass);
      if (D.29996 != 0) goto <D.29997>; else goto <D.29998>;
      <D.29997>:
      context_used = mini_class_check_context_used (cfg, klass);
      size_ins = emit_get_gsharedvt_info_klass (cfg, klass, 14);
      bzero_ins = emit_get_gsharedvt_info_klass (cfg, klass, 23);
      bzero_method.50 = bzero_method;
      if (bzero_method.50 == 0B) goto <D.30000>; else goto <D.30001>;
      <D.30000>:
      D.30002 = mono_defaults.string_class;
      bzero_method.51 = mono_class_get_method_from_name (D.30002, "bzero_aligned_1", 2);
      bzero_method = bzero_method.51;
      <D.30001>:
      bzero_method.50 = bzero_method;
      D.30004 = bzero_method.50 == 0B;
      D.30005 = (long int) D.30004;
      D.30006 = __builtin_expect (D.30005, 0);
      if (D.30006 != 0) goto <D.30007>; else goto <D.30008>;
      <D.30007>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3163, "bzero_method");
      <D.30008>:
      iargs[0] = dest;
      iargs[1] = size_ins;
      bzero_method.50 = bzero_method;
      D.30009 = mono_method_signature (bzero_method.50);
      mono_emit_calli (cfg, D.30009, &iargs, bzero_ins, 0B, 0B);
      return;
      <D.29998>:
      n = mono_class_value_size (klass, &align);
      n.52 = (unsigned int) n;
      if (n.52 <= 40) goto <D.30011>; else goto <D.30012>;
      <D.30011>:
      D.30013 = dest->dreg;
      align.53 = align;
      align.54 = (int) align.53;
      mini_emit_memset (cfg, D.30013, 0, n, 0, align.54);
      goto <D.30016>;
      <D.30012>:
      memset_method = get_memset_method ();
      iargs[0] = dest;
      D.30017 = cfg->mempool;
      D.30018 = mono_mempool_alloc (D.30017, 80);
      iargs[1] = D.30018;
      D.30019 = iargs[1];
      D.30019 = iargs[1];
      D.30019->data.op[1].const_val = 0;
      D.30020 = D.30019->data.op[1].const_val;
      D.30019->data.op[0].const_val = D.30020;
      D.30019 = iargs[1];
      D.30019 = iargs[1];
      D.30019->prev = 0B;
      D.30021 = D.30019->prev;
      D.30019->next = D.30021;
      D.30019 = iargs[1];
      D.30019->opcode = 362;
      D.30019 = iargs[1];
      D.30019->flags = 0;
      D.30019 = iargs[1];
      D.30019->type = 0;
      D.30019 = iargs[1];
      D.30019->dreg = -1;
      D.30019 = iargs[1];
      D.30019 = iargs[1];
      D.30019 = iargs[1];
      D.30019->sreg3 = -1;
      D.30022 = D.30019->sreg3;
      D.30019->sreg2 = D.30022;
      D.30023 = D.30019->sreg2;
      D.30019->sreg1 = D.30023;
      D.30019 = iargs[1];
      D.30024 = cfg->ip;
      D.30019->cil_code = D.30024;
      D.30019 = iargs[1];
      D.30019->data.op[0].const_val = 0;
      D.30019 = iargs[1];
      D.30019->type = 1;
      D.30019 = iargs[1];
      D.30025 = alloc_dreg (cfg, 1);
      D.30026 = (int) D.30025;
      D.30019->dreg = D.30026;
      D.30027 = cfg->cbb;
      D.30028 = D.30027->last_ins;
      if (D.30028 != 0B) goto <D.30029>; else goto <D.30030>;
      <D.30029>:
      D.30027 = cfg->cbb;
      D.30028 = D.30027->last_ins;
      D.30019 = iargs[1];
      D.30028->next = D.30019;
      D.30019 = iargs[1];
      D.30027 = cfg->cbb;
      D.30028 = D.30027->last_ins;
      D.30019->prev = D.30028;
      D.30027 = cfg->cbb;
      D.30019 = iargs[1];
      D.30027->last_ins = D.30019;
      goto <D.30031>;
      <D.30030>:
      D.30027 = cfg->cbb;
      D.30027 = cfg->cbb;
      D.30019 = iargs[1];
      D.30027->last_ins = D.30019;
      D.30028 = D.30027->last_ins;
      D.30027->code = D.30028;
      <D.30031>:
      D.30017 = cfg->mempool;
      D.30032 = mono_mempool_alloc (D.30017, 80);
      iargs[2] = D.30032;
      D.30033 = iargs[2];
      D.30033 = iargs[2];
      D.30033->data.op[1].const_val = 0;
      D.30034 = D.30033->data.op[1].const_val;
      D.30033->data.op[0].const_val = D.30034;
      D.30033 = iargs[2];
      D.30033 = iargs[2];
      D.30033->prev = 0B;
      D.30035 = D.30033->prev;
      D.30033->next = D.30035;
      D.30033 = iargs[2];
      D.30033->opcode = 362;
      D.30033 = iargs[2];
      D.30033->flags = 0;
      D.30033 = iargs[2];
      D.30033->type = 0;
      D.30033 = iargs[2];
      D.30033->dreg = -1;
      D.30033 = iargs[2];
      D.30033 = iargs[2];
      D.30033 = iargs[2];
      D.30033->sreg3 = -1;
      D.30036 = D.30033->sreg3;
      D.30033->sreg2 = D.30036;
      D.30037 = D.30033->sreg2;
      D.30033->sreg1 = D.30037;
      D.30033 = iargs[2];
      D.30024 = cfg->ip;
      D.30033->cil_code = D.30024;
      D.30033 = iargs[2];
      D.30038 = (long int) n;
      D.30033->data.op[0].const_val = D.30038;
      D.30033 = iargs[2];
      D.30033->type = 1;
      D.30033 = iargs[2];
      D.30039 = alloc_dreg (cfg, 1);
      D.30040 = (int) D.30039;
      D.30033->dreg = D.30040;
      D.30027 = cfg->cbb;
      D.30028 = D.30027->last_ins;
      if (D.30028 != 0B) goto <D.30041>; else goto <D.30042>;
      <D.30041>:
      D.30027 = cfg->cbb;
      D.30028 = D.30027->last_ins;
      D.30033 = iargs[2];
      D.30028->next = D.30033;
      D.30033 = iargs[2];
      D.30027 = cfg->cbb;
      D.30028 = D.30027->last_ins;
      D.30033->prev = D.30028;
      D.30027 = cfg->cbb;
      D.30033 = iargs[2];
      D.30027->last_ins = D.30033;
      goto <D.30043>;
      <D.30042>:
      D.30027 = cfg->cbb;
      D.30027 = cfg->cbb;
      D.30033 = iargs[2];
      D.30027->last_ins = D.30033;
      D.30028 = D.30027->last_ins;
      D.30027->code = D.30028;
      <D.30043>:
      mono_emit_method_call (cfg, memset_method, &iargs, 0B);
      <D.30016>:
    }
  finally
    {
      iargs = {CLOBBER};
      align = {CLOBBER};
    }
}


mini_emit_memset (struct MonoCompile * cfg, int destreg, int offset, int size, int val, int align)
{
  _Bool D.30047;
  long int D.30048;
  long int D.30049;
  struct MonoMemPool * D.30058;
  long int D.30059;
  struct MonoInst * D.30060;
  int D.30061;
  int D.30062;
  const unsigned char * D.30063;
  long int D.30064;
  long int D.30065;
  struct MonoBasicBlock * D.30066;
  struct MonoInst * D.30067;
  long int D.30071;
  struct MonoInst * D.30072;
  int D.30073;
  int D.30074;
  long int D.30078;
  struct MonoInst * D.30079;
  int D.30080;
  int D.30081;
  long int D.30085;
  struct MonoInst * D.30086;
  int D.30087;
  int D.30088;
  unsigned int D.30093;
  long int D.30096;
  struct MonoInst * D.30097;
  int D.30098;
  int D.30099;
  long int D.30100;
  long int D.30105;
  struct MonoInst * D.30106;
  int D.30107;
  int D.30108;
  long int D.30109;
  long int D.30115;
  struct MonoInst * D.30116;
  int D.30117;
  int D.30118;
  unsigned int offset.55;
  unsigned int D.30125;
  long int D.30128;
  struct MonoInst * D.30129;
  int D.30130;
  int D.30131;
  long int D.30135;
  struct MonoInst * D.30136;
  int D.30137;
  int D.30138;
  long int D.30142;
  struct MonoInst * D.30143;
  int D.30144;
  int D.30145;
  long int D.30149;
  struct MonoInst * D.30150;
  int D.30151;
  int D.30152;
  long int D.30156;
  struct MonoInst * D.30157;
  int D.30158;
  int D.30159;
  int val_reg;

  D.30047 = val != 0;
  D.30048 = (long int) D.30047;
  D.30049 = __builtin_expect (D.30048, 0);
  if (D.30049 != 0) goto <D.30050>; else goto <D.30051>;
  <D.30050>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1744, "val == 0");
  <D.30051>:
  if (align == 0) goto <D.30052>; else goto <D.30053>;
  <D.30052>:
  align = 4;
  <D.30053>:
  if (size <= 4) goto <D.30054>; else goto <D.30055>;
  <D.30054>:
  if (size <= align) goto <D.30056>; else goto <D.30057>;
  <D.30056>:
  switch (size) <default: <D.30092>, case 1: <D.25611>, case 2: <D.25613>, case 4: <D.25615>, case 8: <D.25617>>
  <D.25611>:
  {
    struct MonoInst * inst;

    D.30058 = cfg->mempool;
    inst = mono_mempool_alloc (D.30058, 80);
    inst->data.op[1].const_val = 0;
    D.30059 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30059;
    inst->prev = 0B;
    D.30060 = inst->prev;
    inst->next = D.30060;
    inst->opcode = 382;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30061 = inst->sreg3;
    inst->sreg2 = D.30061;
    D.30062 = inst->sreg2;
    inst->sreg1 = D.30062;
    D.30063 = cfg->ip;
    inst->cil_code = D.30063;
    inst->dreg = destreg;
    D.30064 = (long int) offset;
    inst->data.op[0].const_val = D.30064;
    D.30065 = (long int) val;
    inst->data.op[1].const_val = D.30065;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    if (D.30067 != 0B) goto <D.30068>; else goto <D.30069>;
    <D.30068>:
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    D.30067->next = inst;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    inst->prev = D.30067;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    goto <D.30070>;
    <D.30069>:
    D.30066 = cfg->cbb;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    D.30067 = D.30066->last_ins;
    D.30066->code = D.30067;
    <D.30070>:
  }
  return;
  <D.25613>:
  {
    struct MonoInst * inst;

    D.30058 = cfg->mempool;
    inst = mono_mempool_alloc (D.30058, 80);
    inst->data.op[1].const_val = 0;
    D.30071 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30071;
    inst->prev = 0B;
    D.30072 = inst->prev;
    inst->next = D.30072;
    inst->opcode = 383;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30073 = inst->sreg3;
    inst->sreg2 = D.30073;
    D.30074 = inst->sreg2;
    inst->sreg1 = D.30074;
    D.30063 = cfg->ip;
    inst->cil_code = D.30063;
    inst->dreg = destreg;
    D.30064 = (long int) offset;
    inst->data.op[0].const_val = D.30064;
    D.30065 = (long int) val;
    inst->data.op[1].const_val = D.30065;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    if (D.30067 != 0B) goto <D.30075>; else goto <D.30076>;
    <D.30075>:
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    D.30067->next = inst;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    inst->prev = D.30067;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    goto <D.30077>;
    <D.30076>:
    D.30066 = cfg->cbb;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    D.30067 = D.30066->last_ins;
    D.30066->code = D.30067;
    <D.30077>:
  }
  return;
  <D.25615>:
  {
    struct MonoInst * inst;

    D.30058 = cfg->mempool;
    inst = mono_mempool_alloc (D.30058, 80);
    inst->data.op[1].const_val = 0;
    D.30078 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30078;
    inst->prev = 0B;
    D.30079 = inst->prev;
    inst->next = D.30079;
    inst->opcode = 384;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30080 = inst->sreg3;
    inst->sreg2 = D.30080;
    D.30081 = inst->sreg2;
    inst->sreg1 = D.30081;
    D.30063 = cfg->ip;
    inst->cil_code = D.30063;
    inst->dreg = destreg;
    D.30064 = (long int) offset;
    inst->data.op[0].const_val = D.30064;
    D.30065 = (long int) val;
    inst->data.op[1].const_val = D.30065;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    if (D.30067 != 0B) goto <D.30082>; else goto <D.30083>;
    <D.30082>:
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    D.30067->next = inst;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    inst->prev = D.30067;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    goto <D.30084>;
    <D.30083>:
    D.30066 = cfg->cbb;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    D.30067 = D.30066->last_ins;
    D.30066->code = D.30067;
    <D.30084>:
  }
  return;
  <D.25617>:
  {
    struct MonoInst * inst;

    D.30058 = cfg->mempool;
    inst = mono_mempool_alloc (D.30058, 80);
    inst->data.op[1].const_val = 0;
    D.30085 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30085;
    inst->prev = 0B;
    D.30086 = inst->prev;
    inst->next = D.30086;
    inst->opcode = 385;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30087 = inst->sreg3;
    inst->sreg2 = D.30087;
    D.30088 = inst->sreg2;
    inst->sreg1 = D.30088;
    D.30063 = cfg->ip;
    inst->cil_code = D.30063;
    inst->dreg = destreg;
    D.30064 = (long int) offset;
    inst->data.op[0].const_val = D.30064;
    D.30065 = (long int) val;
    inst->data.op[1].const_val = D.30065;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    if (D.30067 != 0B) goto <D.30089>; else goto <D.30090>;
    <D.30089>:
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    D.30067->next = inst;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    inst->prev = D.30067;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    goto <D.30091>;
    <D.30090>:
    D.30066 = cfg->cbb;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    D.30067 = D.30066->last_ins;
    D.30066->code = D.30067;
    <D.30091>:
  }
  return;
  <D.30092>:
  <D.30057>:
  <D.30055>:
  D.30093 = alloc_preg (cfg);
  val_reg = (int) D.30093;
  if (1 != 0) goto <D.30094>; else goto <D.30095>;
  <D.30094>:
  {
    struct MonoInst * inst;

    D.30058 = cfg->mempool;
    inst = mono_mempool_alloc (D.30058, 80);
    inst->data.op[1].const_val = 0;
    D.30096 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30096;
    inst->prev = 0B;
    D.30097 = inst->prev;
    inst->next = D.30097;
    inst->opcode = 363;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30098 = inst->sreg3;
    inst->sreg2 = D.30098;
    D.30099 = inst->sreg2;
    inst->sreg1 = D.30099;
    D.30063 = cfg->ip;
    inst->cil_code = D.30063;
    inst->dreg = val_reg;
    D.30100 = (long int) val;
    inst->data.i8const = D.30100;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    if (D.30067 != 0B) goto <D.30101>; else goto <D.30102>;
    <D.30101>:
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    D.30067->next = inst;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    inst->prev = D.30067;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    goto <D.30103>;
    <D.30102>:
    D.30066 = cfg->cbb;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    D.30067 = D.30066->last_ins;
    D.30066->code = D.30067;
    <D.30103>:
  }
  goto <D.30104>;
  <D.30095>:
  {
    struct MonoInst * inst;

    D.30058 = cfg->mempool;
    inst = mono_mempool_alloc (D.30058, 80);
    inst->data.op[1].const_val = 0;
    D.30105 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30105;
    inst->prev = 0B;
    D.30106 = inst->prev;
    inst->next = D.30106;
    inst->opcode = 362;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30107 = inst->sreg3;
    inst->sreg2 = D.30107;
    D.30108 = inst->sreg2;
    inst->sreg1 = D.30108;
    D.30063 = cfg->ip;
    inst->cil_code = D.30063;
    inst->dreg = val_reg;
    D.30109 = (long int) val;
    inst->data.op[0].const_val = D.30109;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    if (D.30067 != 0B) goto <D.30110>; else goto <D.30111>;
    <D.30110>:
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    D.30067->next = inst;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    inst->prev = D.30067;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    goto <D.30112>;
    <D.30111>:
    D.30066 = cfg->cbb;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    D.30067 = D.30066->last_ins;
    D.30066->code = D.30067;
    <D.30112>:
  }
  <D.30104>:
  if (align <= 3) goto <D.30113>; else goto <D.30114>;
  <D.30113>:
  goto <D.25623>;
  <D.25622>:
  {
    struct MonoInst * inst;

    D.30058 = cfg->mempool;
    inst = mono_mempool_alloc (D.30058, 80);
    inst->data.op[1].const_val = 0;
    D.30115 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30115;
    inst->prev = 0B;
    D.30116 = inst->prev;
    inst->next = D.30116;
    inst->opcode = 375;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30117 = inst->sreg3;
    inst->sreg2 = D.30117;
    D.30118 = inst->sreg2;
    inst->sreg1 = D.30118;
    D.30063 = cfg->ip;
    inst->cil_code = D.30063;
    inst->sreg1 = val_reg;
    inst->dreg = destreg;
    D.30064 = (long int) offset;
    inst->data.op[0].const_val = D.30064;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    if (D.30067 != 0B) goto <D.30119>; else goto <D.30120>;
    <D.30119>:
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    D.30067->next = inst;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    inst->prev = D.30067;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    goto <D.30121>;
    <D.30120>:
    D.30066 = cfg->cbb;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    D.30067 = D.30066->last_ins;
    D.30066->code = D.30067;
    <D.30121>:
  }
  offset = offset + 1;
  size = size + -1;
  <D.25623>:
  if (size > 0) goto <D.25622>; else goto <D.25624>;
  <D.25624>:
  return;
  <D.30114>:
  if (1 != 0) goto <D.30122>; else goto <D.30123>;
  <D.30122>:
  offset.55 = (unsigned int) offset;
  D.30125 = offset.55 & 7;
  if (D.30125 != 0) goto <D.30126>; else goto <D.30127>;
  <D.30126>:
  {
    struct MonoInst * inst;

    D.30058 = cfg->mempool;
    inst = mono_mempool_alloc (D.30058, 80);
    inst->data.op[1].const_val = 0;
    D.30128 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30128;
    inst->prev = 0B;
    D.30129 = inst->prev;
    inst->next = D.30129;
    inst->opcode = 377;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30130 = inst->sreg3;
    inst->sreg2 = D.30130;
    D.30131 = inst->sreg2;
    inst->sreg1 = D.30131;
    D.30063 = cfg->ip;
    inst->cil_code = D.30063;
    inst->sreg1 = val_reg;
    inst->dreg = destreg;
    D.30064 = (long int) offset;
    inst->data.op[0].const_val = D.30064;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    if (D.30067 != 0B) goto <D.30132>; else goto <D.30133>;
    <D.30132>:
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    D.30067->next = inst;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    inst->prev = D.30067;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    goto <D.30134>;
    <D.30133>:
    D.30066 = cfg->cbb;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    D.30067 = D.30066->last_ins;
    D.30066->code = D.30067;
    <D.30134>:
  }
  offset = offset + 4;
  size = size + -4;
  <D.30127>:
  goto <D.25628>;
  <D.25627>:
  {
    struct MonoInst * inst;

    D.30058 = cfg->mempool;
    inst = mono_mempool_alloc (D.30058, 80);
    inst->data.op[1].const_val = 0;
    D.30135 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30135;
    inst->prev = 0B;
    D.30136 = inst->prev;
    inst->next = D.30136;
    inst->opcode = 378;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30137 = inst->sreg3;
    inst->sreg2 = D.30137;
    D.30138 = inst->sreg2;
    inst->sreg1 = D.30138;
    D.30063 = cfg->ip;
    inst->cil_code = D.30063;
    inst->sreg1 = val_reg;
    inst->dreg = destreg;
    D.30064 = (long int) offset;
    inst->data.op[0].const_val = D.30064;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    if (D.30067 != 0B) goto <D.30139>; else goto <D.30140>;
    <D.30139>:
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    D.30067->next = inst;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    inst->prev = D.30067;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    goto <D.30141>;
    <D.30140>:
    D.30066 = cfg->cbb;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    D.30067 = D.30066->last_ins;
    D.30066->code = D.30067;
    <D.30141>:
  }
  offset = offset + 8;
  size = size + -8;
  <D.25628>:
  if (size > 7) goto <D.25627>; else goto <D.25629>;
  <D.25629>:
  <D.30123>:
  goto <D.25632>;
  <D.25631>:
  {
    struct MonoInst * inst;

    D.30058 = cfg->mempool;
    inst = mono_mempool_alloc (D.30058, 80);
    inst->data.op[1].const_val = 0;
    D.30142 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30142;
    inst->prev = 0B;
    D.30143 = inst->prev;
    inst->next = D.30143;
    inst->opcode = 377;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30144 = inst->sreg3;
    inst->sreg2 = D.30144;
    D.30145 = inst->sreg2;
    inst->sreg1 = D.30145;
    D.30063 = cfg->ip;
    inst->cil_code = D.30063;
    inst->sreg1 = val_reg;
    inst->dreg = destreg;
    D.30064 = (long int) offset;
    inst->data.op[0].const_val = D.30064;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    if (D.30067 != 0B) goto <D.30146>; else goto <D.30147>;
    <D.30146>:
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    D.30067->next = inst;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    inst->prev = D.30067;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    goto <D.30148>;
    <D.30147>:
    D.30066 = cfg->cbb;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    D.30067 = D.30066->last_ins;
    D.30066->code = D.30067;
    <D.30148>:
  }
  offset = offset + 4;
  size = size + -4;
  <D.25632>:
  if (size > 3) goto <D.25631>; else goto <D.25633>;
  <D.25633>:
  goto <D.25636>;
  <D.25635>:
  {
    struct MonoInst * inst;

    D.30058 = cfg->mempool;
    inst = mono_mempool_alloc (D.30058, 80);
    inst->data.op[1].const_val = 0;
    D.30149 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30149;
    inst->prev = 0B;
    D.30150 = inst->prev;
    inst->next = D.30150;
    inst->opcode = 376;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30151 = inst->sreg3;
    inst->sreg2 = D.30151;
    D.30152 = inst->sreg2;
    inst->sreg1 = D.30152;
    D.30063 = cfg->ip;
    inst->cil_code = D.30063;
    inst->sreg1 = val_reg;
    inst->dreg = destreg;
    D.30064 = (long int) offset;
    inst->data.op[0].const_val = D.30064;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    if (D.30067 != 0B) goto <D.30153>; else goto <D.30154>;
    <D.30153>:
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    D.30067->next = inst;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    inst->prev = D.30067;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    goto <D.30155>;
    <D.30154>:
    D.30066 = cfg->cbb;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    D.30067 = D.30066->last_ins;
    D.30066->code = D.30067;
    <D.30155>:
  }
  offset = offset + 2;
  size = size + -2;
  <D.25636>:
  if (size > 1) goto <D.25635>; else goto <D.25637>;
  <D.25637>:
  goto <D.25640>;
  <D.25639>:
  {
    struct MonoInst * inst;

    D.30058 = cfg->mempool;
    inst = mono_mempool_alloc (D.30058, 80);
    inst->data.op[1].const_val = 0;
    D.30156 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.30156;
    inst->prev = 0B;
    D.30157 = inst->prev;
    inst->next = D.30157;
    inst->opcode = 375;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.30158 = inst->sreg3;
    inst->sreg2 = D.30158;
    D.30159 = inst->sreg2;
    inst->sreg1 = D.30159;
    D.30063 = cfg->ip;
    inst->cil_code = D.30063;
    inst->sreg1 = val_reg;
    inst->dreg = destreg;
    D.30064 = (long int) offset;
    inst->data.op[0].const_val = D.30064;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    if (D.30067 != 0B) goto <D.30160>; else goto <D.30161>;
    <D.30160>:
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    D.30067->next = inst;
    D.30066 = cfg->cbb;
    D.30067 = D.30066->last_ins;
    inst->prev = D.30067;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    goto <D.30162>;
    <D.30161>:
    D.30066 = cfg->cbb;
    D.30066 = cfg->cbb;
    D.30066->last_ins = inst;
    D.30067 = D.30066->last_ins;
    D.30066->code = D.30067;
    <D.30162>:
  }
  offset = offset + 1;
  size = size + -1;
  <D.25640>:
  if (size > 0) goto <D.25639>; else goto <D.25641>;
  <D.25641>:
}


get_memset_method ()
{
  struct MonoMethod * memset_method.56;
  struct MonoClass * D.30167;
  struct MonoMethod * memset_method.57;
  struct MonoMethod * D.30171;
  static struct MonoMethod * memset_method = 0B;

  memset_method.56 = memset_method;
  if (memset_method.56 == 0B) goto <D.30165>; else goto <D.30166>;
  <D.30165>:
  D.30167 = mono_defaults.string_class;
  memset_method.57 = mono_class_get_method_from_name (D.30167, "memset", 3);
  memset_method = memset_method.57;
  memset_method.56 = memset_method;
  if (memset_method.56 == 0B) goto <D.30169>; else goto <D.30170>;
  <D.30169>:
  monoeg_g_log (0B, 4, "Old corlib found. Install a new one");
  <D.26089>:
  goto <D.26089>;
  <D.30170>:
  <D.30166>:
  D.30171 = memset_method;
  return D.30171;
}


mono_set_break_policy (MonoBreakPolicy (*MonoBreakPolicyFunc) (struct MonoMethod *) policy_callback)
{
  if (policy_callback != 0B) goto <D.30173>; else goto <D.30174>;
  <D.30173>:
  break_policy_func = policy_callback;
  goto <D.30175>;
  <D.30174>:
  break_policy_func = always_insert_breakpoint;
  <D.30175>:
}


always_insert_breakpoint (struct MonoMethod * method)
{
  MonoBreakPolicy D.30176;

  D.30176 = 0;
  return D.30176;
}


__attribute__((visibility ("hidden")))
mono_method_to_ir (struct MonoCompile * cfg, struct MonoMethod * method, struct MonoBasicBlock * start_bblock, struct MonoBasicBlock * end_bblock, struct MonoInst * return_var, struct GList * dont_inline, struct MonoInst * * inline_args, guint inline_offset, gboolean is_virtual_call)
{
  struct MonoClass * D.30178;
  struct MonoImage * D.30179;
  struct MonoAssembly * D.30180;
  unsigned char D.30181;
  _Bool D.30182;
  long unsigned int D.30183;
  long unsigned int D.30184;
  _Bool D.30185;
  int D.30186;
  _Bool D.30187;
  int D.30188;
  _Bool D.30189;
  int D.30190;
  _Bool D.30191;
  int D.30192;
  _Bool D.30193;
  int D.30194;
  <unnamed type> D.30195;
  _Bool D.30196;
  int D.30197;
  _Bool D.30198;
  int D.30199;
  _Bool D.30200;
  int D.30201;
  _Bool D.30202;
  int D.30203;
  unsigned char D.30208;
  int D.30209;
  struct MonoMethod * D.30211;
  const char * D.30212;
  gchar * D.30213;
  <unnamed-unsigned:1> D.30214;
  int D.30215;
  short unsigned int D.30216;
  int D.30217;
  int D.30218;
  unsigned int D.30219;
  sizetype D.30220;
  int D.30221;
  unsigned int D.30222;
  unsigned int D.30223;
  int D.30224;
  <unnamed-unsigned:1> D.30225;
  int iftmp.58;
  long unsigned int D.30229;
  long unsigned int D.30230;
  struct MonoMemPool * D.30241;
  unsigned int D.30242;
  void * D.30243;
  unsigned int D.30244;
  void * D.30245;
  int * il_offsets.59;
  long unsigned int D.30247;
  long unsigned int D.30248;
  int * D.30249;
  int D.30250;
  unsigned int D.30251;
  long unsigned int D.30254;
  long unsigned int D.30255;
  long unsigned int D.30256;
  unsigned int D.30257;
  unsigned int D.30258;
  long unsigned int D.30259;
  long unsigned int D.30260;
  int n_il_offsets.60;
  int * line_numbers.61;
  long unsigned int D.30263;
  long unsigned int D.30264;
  struct MonoDomain * D.30267;
  int D.30268;
  long unsigned int D.30271;
  long unsigned int D.30272;
  struct MonoGenericSharingContext * D.30278;
  long unsigned int D.30281;
  _Bool D.30282;
  long int D.30283;
  long int D.30284;
  short unsigned int D.30287;
  long unsigned int D.30292;
  _Bool D.30293;
  long int D.30294;
  long int D.30295;
  struct MonoGenericContext * D.30298;
  struct MonoGenericInst * D.30299;
  _Bool D.30300;
  long int D.30301;
  long int D.30302;
  struct MonoGenericContext * D.30307;
  struct MonoGenericInst * D.30308;
  _Bool D.30311;
  long int D.30312;
  long int D.30313;
  unsigned int D.30319;
  void * D.30320;
  int D.30321;
  unsigned int D.30322;
  char * D.30325;
  unsigned int D.30326;
  long unsigned int D.30327;
  struct MonoType * iftmp.62;
  long unsigned int D.30331;
  long unsigned int D.30332;
  int D.30336;
  long unsigned int D.30337;
  long unsigned int D.30338;
  struct MonoType * * D.30339;
  struct MonoType * D.30340;
  unsigned int D.30343;
  unsigned int D.30344;
  int D.30347;
  struct MonoProfileCoverageInfo * D.30348;
  unsigned int D.30349;
  unsigned int D.30350;
  unsigned int D.30351;
  int D.30352;
  unsigned int D.30353;
  unsigned int D.30354;
  int D.30355;
  unsigned int D.30356;
  unsigned int D.30357;
  _Bool D.30358;
  long int D.30359;
  long int D.30360;
  long unsigned int D.30363;
  long unsigned int D.30364;
  struct GHashTable * D.30367;
  struct GHashTable * D.30368;
  struct MonoExceptionClause * D.30369;
  long unsigned int D.30370;
  long unsigned int D.30371;
  struct MonoBasicBlock * * D.30372;
  unsigned int D.30373;
  sizetype D.30374;
  unsigned char * D.30375;
  long int D.30376;
  unsigned char * D.30377;
  long int D.30378;
  long int D.30379;
  long unsigned int D.30380;
  long unsigned int D.30381;
  struct MonoBasicBlock * * D.30382;
  const unsigned char * D.30388;
  int D.30389;
  struct MonoDebugOptions * D.30394;
  int D.30395;
  unsigned int D.30397;
  unsigned int D.30398;
  int D.30399;
  unsigned char * D.30400;
  long int D.30403;
  long int D.30404;
  long unsigned int D.30405;
  long unsigned int D.30406;
  struct MonoBasicBlock * * D.30407;
  unsigned int D.30408;
  int D.30409;
  int D.30410;
  unsigned int D.30411;
  unsigned int D.30412;
  unsigned int D.30413;
  unsigned int D.30414;
  sizetype D.30415;
  unsigned char * D.30416;
  long int D.30417;
  long int D.30418;
  long unsigned int D.30419;
  long unsigned int D.30420;
  struct MonoBasicBlock * * D.30421;
  struct MonoDebugOptions * D.30431;
  int D.30432;
  unsigned int D.30434;
  unsigned int D.30435;
  int D.30436;
  unsigned char * D.30437;
  long int D.30440;
  long int D.30441;
  long unsigned int D.30442;
  long unsigned int D.30443;
  struct MonoBasicBlock * * D.30444;
  unsigned int D.30445;
  unsigned int D.30446;
  unsigned char D.30449;
  unsigned int D.30452;
  unsigned int D.30455;
  long int D.30457;
  struct MonoInst * D.30458;
  int D.30459;
  int D.30460;
  const unsigned char * D.30461;
  struct MonoInst * D.30462;
  long int D.30470;
  unsigned int D.30476;
  void * D.30479;
  struct MonoInst * * D.30480;
  int D.30481;
  struct MonoInst * D.30482;
  long int D.30483;
  struct MonoInst * D.30484;
  int D.30485;
  int D.30486;
  struct MonoInst * D.30487;
  int D.30488;
  struct MonoBasicBlock * bblock.106;
  struct MonoInst * D.30490;
  unsigned int D.30496;
  sizetype D.30497;
  unsigned char * D.30498;
  long int D.30499;
  long int D.30500;
  long unsigned int D.30501;
  long unsigned int D.30502;
  struct MonoBasicBlock * * D.30503;
  struct MonoDebugOptions * D.30513;
  int D.30514;
  unsigned int D.30516;
  unsigned int D.30517;
  int D.30518;
  void * D.30521;
  struct MonoInst * D.30522;
  struct MonoClass * D.30528;
  int D.30533;
  short unsigned int D.30539;
  int D.30540;
  int D.30541;
  struct MonoGenericContext * D.30543;
  struct MonoGenericInst * D.30544;
  long int D.30546;
  struct MonoInst * D.30547;
  int D.30548;
  int D.30549;
  struct MonoInst * D.30550;
  int D.30551;
  <unnamed-unsigned:15> D.30555;
  int D.30556;
  long unsigned int D.30558;
  long unsigned int D.30559;
  void * bblock.63;
  struct MonoBasicBlock * bblock.64;
  unsigned int D.30562;
  unsigned int D.30563;
  int D.30564;
  unsigned char * D.30565;
  long int D.30568;
  long int D.30569;
  long unsigned int D.30570;
  long unsigned int D.30571;
  struct MonoBasicBlock * * D.30572;
  struct MonoInst * D.30577;
  <unnamed type> D.30581;
  int iftmp.65;
  unsigned char D.30588;
  int iftmp.66;
  short unsigned int D.30604;
  int D.30605;
  int D.30606;
  struct MonoClass * D.30610;
  int D.30611;
  struct MonoClass * D.30618;
  int D.30621;
  unsigned int D.30632;
  unsigned int D.30633;
  long unsigned int D.30634;
  long unsigned int D.30635;
  unsigned int D.30638;
  unsigned int D.30639;
  int D.30640;
  struct GPtrArray * D.30645;
  struct MonoClass * D.30646;
  struct MonoType * D.30647;
  int D.30648;
  long int D.30649;
  struct MonoInst * D.30650;
  int D.30651;
  int D.30652;
  int D.30653;
  int D.30654;
  unsigned int D.30658;
  long int D.30659;
  struct MonoInst * D.30660;
  int D.30661;
  int D.30662;
  int D.30666;
  unsigned int D.30670;
  unsigned int D.30671;
  int D.30676;
  int D.30677;
  char * D.30678;
  void * D.30683;
  struct MonoInst * D.30684;
  long int D.30685;
  struct MonoInst * D.30686;
  int D.30687;
  int D.30688;
  unsigned int D.30689;
  struct MonoJumpInfoToken * D.30690;
  unsigned int D.30691;
  int D.30692;
  void * D.30694;
  unsigned int D.30695;
  int D.30696;
  void * D.30700;
  struct MonoInst * D.30701;
  long int D.30702;
  struct MonoInst * D.30703;
  int D.30704;
  int D.30705;
  unsigned int D.30706;
  long int D.30707;
  unsigned int D.30708;
  int D.30709;
  struct MonoMethod * D.30713;
  char * D.30714;
  void * D.30719;
  unsigned int D.30720;
  struct MonoJumpInfoToken * D.30721;
  unsigned int D.30722;
  int D.30723;
  void * D.30725;
  unsigned int D.30726;
  int D.30727;
  void * D.30731;
  unsigned int D.30732;
  long int D.30733;
  unsigned int D.30734;
  int D.30735;
  char * D.30739;
  void * D.30744;
  unsigned int D.30745;
  struct MonoJumpInfoToken * D.30746;
  unsigned int D.30747;
  int D.30748;
  void * D.30750;
  unsigned int D.30751;
  int D.30752;
  void * D.30756;
  unsigned int D.30757;
  long int D.30758;
  unsigned int D.30759;
  int D.30760;
  struct MonoMethod * D.30764;
  struct MonoMethod * D.30767;
  <unnamed type> D.30768;
  short unsigned int D.30775;
  int D.30776;
  short unsigned int D.30777;
  int D.30778;
  int D.30786;
  struct MonoException * iftmp.67;
  unsigned int D.30793;
  struct MonoDebugOptions * D.30801;
  int D.30802;
  int D.30804;
  struct MonoDebugOptions * D.30811;
  int D.30812;
  unsigned int breakpoint_id.68;
  struct MonoType * D.30817;
  long unsigned int D.30818;
  long unsigned int D.30819;
  struct MonoDebugOptions * D.30826;
  int D.30827;
  short unsigned int D.30829;
  int D.30830;
  struct MonoGenericContext * D.30839;
  struct MonoGenericInst * D.30840;
  struct MonoInst * * D.30842;
  struct MonoInst * D.30843;
  unsigned char D.30844;
  unsigned char D.30845;
  long int D.30848;
  struct MonoInst * D.30849;
  int D.30850;
  int D.30851;
  struct MonoType * * D.30852;
  struct MonoType * D.30853;
  unsigned int D.30854;
  short unsigned int D.30855;
  struct MonoClass * D.30856;
  int D.30857;
  unsigned char D.30858;
  <unnamed type> D.30859;
  unsigned int D.30860;
  int D.30861;
  short unsigned int D.30862;
  struct MonoClass * D.30865;
  unsigned int D.30869;
  long unsigned int D.30870;
  long int D.30875;
  struct MonoInst * D.30876;
  int D.30877;
  int D.30878;
  int D.30879;
  long int D.30883;
  struct MonoInst * D.30884;
  int D.30885;
  int D.30886;
  long int D.30892;
  struct MonoInst * D.30893;
  int D.30894;
  int D.30895;
  long int D.30899;
  struct MonoInst * D.30900;
  int D.30901;
  int D.30902;
  _Bool D.30906;
  int D.30909;
  struct MonoDebugOptions * D.30916;
  int D.30917;
  _Bool D.30919;
  long int D.30920;
  long int D.30921;
  <unnamed-unsigned:15> D.30924;
  int D.30925;
  int D.30926;
  long unsigned int D.30927;
  unsigned int D.30928;
  unsigned int D.30929;
  long int ip.69;
  long int D.30933;
  long int D.30934;
  unsigned int D.30935;
  long int D.30939;
  int D.30940;
  _Bool D.30943;
  long int D.30944;
  long int D.30945;
  long int D.30949;
  long unsigned int D.30950;
  long unsigned int D.30951;
  struct MonoBasicBlock * * D.30952;
  struct MonoDebugOptions * D.30962;
  int D.30963;
  unsigned int D.30965;
  unsigned int D.30966;
  int D.30967;
  struct MonoInst * * D.30972;
  long unsigned int D.30973;
  struct MonoInst * * D.30974;
  struct MonoInst * D.30975;
  long int D.30976;
  int D.30977;
  struct MonoInst * * D.30978;
  long unsigned int D.30979;
  long unsigned int D.30980;
  struct MonoInst * * D.30981;
  struct MonoInst * D.30982;
  struct MonoType * D.30983;
  unsigned int D.30984;
  short unsigned int D.30985;
  struct MonoClass * D.30986;
  int D.30987;
  unsigned char D.30988;
  <unnamed type> D.30989;
  unsigned int D.30990;
  int D.30991;
  short unsigned int D.30992;
  struct MonoClass * D.30995;
  struct MonoInst * * sp.70;
  short unsigned int D.31000;
  int D.31001;
  long int sp.71;
  long int stack_start.72;
  long int D.31013;
  long int D.31014;
  int D.31015;
  long unsigned int D.31016;
  struct MonoDebugOptions * D.31023;
  int D.31024;
  unsigned int D.31028;
  short unsigned int D.31029;
  unsigned int D.31030;
  int D.31031;
  struct MonoClass * D.31034;
  struct MonoInst * * sp.73;
  int D.31041;
  long unsigned int D.31044;
  long unsigned int D.31045;
  _Bool D.31048;
  long int D.31049;
  long int D.31050;
  int D.31055;
  sizetype D.31061;
  long unsigned int D.31068;
  long unsigned int D.31069;
  long unsigned int D.31070;
  unsigned int D.31071;
  unsigned int D.31072;
  long unsigned int D.31073;
  long unsigned int D.31074;
  int iftmp.74;
  struct MonoMethodHeader * D.31081;
  long unsigned int D.31082;
  long unsigned int D.31083;
  _Bool D.31084;
  unsigned char D.31085;
  unsigned char D.31088;
  unsigned char D.31089;
  long unsigned int D.31095;
  long unsigned int D.31096;
  long unsigned int D.31097;
  long unsigned int D.31098;
  struct MonoProfileCoverageInfo * D.31101;
  int * D.31104;
  unsigned int D.31105;
  int D.31106;
  long int D.31110;
  struct MonoInst * D.31111;
  int D.31112;
  int D.31113;
  int D.31119;
  char * D.31120;
  unsigned char D.31121;
  int D.31122;
  long unsigned int D.31132;
  int D.31139;
  long int D.31146;
  struct MonoDebugOptions * D.31153;
  int D.31154;
  unsigned int n.75;
  struct MonoDebugOptions * D.31163;
  int D.31164;
  long unsigned int D.31166;
  long unsigned int D.31167;
  struct MonoType * * D.31168;
  struct MonoType * D.31169;
  unsigned int D.31170;
  short unsigned int D.31171;
  struct MonoInst * * D.31172;
  struct MonoInst * D.31173;
  struct MonoClass * D.31174;
  int D.31175;
  unsigned int D.31176;
  int D.31177;
  struct MonoClass * D.31180;
  struct MonoInst * * sp.76;
  struct MonoDebugOptions * D.31191;
  int D.31192;
  unsigned int D.31194;
  struct MonoDebugOptions * D.31201;
  int D.31202;
  unsigned int D.31204;
  short unsigned int D.31205;
  struct MonoInst * * D.31206;
  struct MonoInst * * D.31207;
  struct MonoInst * D.31208;
  struct MonoClass * D.31209;
  int D.31210;
  unsigned int D.31211;
  int D.31212;
  struct MonoClass * D.31215;
  struct MonoInst * * sp.77;
  struct MonoDebugOptions * D.31226;
  int D.31227;
  struct MonoDebugOptions * D.31235;
  int D.31236;
  struct MonoInst * D.31240;
  int D.31241;
  struct MonoDebugOptions * D.31248;
  int D.31249;
  unsigned char * D.31251;
  struct MonoDebugOptions * D.31258;
  int D.31259;
  struct MonoDebugOptions * D.31267;
  int D.31268;
  unsigned char * D.31270;
  unsigned char D.31271;
  struct MonoDebugOptions * D.31278;
  int D.31279;
  unsigned int D.31281;
  short unsigned int D.31282;
  unsigned int D.31283;
  int D.31284;
  struct MonoClass * D.31287;
  struct MonoInst * * sp.78;
  struct MonoDebugOptions * D.31298;
  int D.31299;
  struct MonoDebugOptions * D.31307;
  int D.31308;
  struct MonoDebugOptions * D.31316;
  int D.31317;
  struct MonoInst * * D.31319;
  struct MonoInst * D.31320;
  unsigned char D.31321;
  unsigned char D.31322;
  struct MonoClass * D.31323;
  unsigned int D.31324;
  int D.31325;
  _Bool D.31326;
  long int D.31327;
  long int D.31328;
  struct MonoType * D.31331;
  int D.31332;
  struct MonoInst * iftmp.79;
  int D.31338;
  int D.31339;
  unsigned int D.31340;
  unsigned int D.31341;
  struct MonoInst * * D.31344;
  sizetype D.31345;
  sizetype D.31346;
  sizetype D.31347;
  struct MonoInst * * D.31348;
  struct MonoInst * iftmp.80;
  int D.31351;
  unsigned int D.31352;
  sizetype D.31355;
  sizetype D.31356;
  struct MonoInst * * D.31357;
  _Bool D.31359;
  long int D.31360;
  long int D.31361;
  _Bool D.31364;
  long int D.31365;
  long int D.31366;
  unsigned char D.31369;
  unsigned char D.31370;
  unsigned char D.31371;
  unsigned char D.31372;
  struct MonoInst * * sp.81;
  struct MonoDebugOptions * D.31383;
  int D.31384;
  struct MonoDebugOptions * D.31392;
  int D.31393;
  struct MonoDebugOptions * D.31401;
  int D.31402;
  long unsigned int D.31406;
  long unsigned int D.31407;
  struct MonoType * * D.31408;
  struct MonoType * D.31409;
  int D.31410;
  struct MonoDebugOptions * D.31417;
  int D.31418;
  unsigned int D.31420;
  short unsigned int D.31421;
  int D.31422;
  struct MonoClass * D.31425;
  struct MonoDebugOptions * D.31435;
  int D.31436;
  struct MonoDebugOptions * D.31444;
  int D.31445;
  struct MonoDebugOptions * D.31453;
  int D.31454;
  unsigned int D.31456;
  short unsigned int D.31457;
  unsigned int D.31458;
  int D.31459;
  struct MonoClass * D.31462;
  struct MonoInst * * sp.82;
  struct MonoDebugOptions * D.31473;
  int D.31474;
  struct MonoDebugOptions * D.31482;
  int D.31483;
  short unsigned int D.31485;
  struct MonoDebugOptions * D.31492;
  int D.31493;
  struct MonoInst * * D.31497;
  struct MonoInst * D.31498;
  unsigned char D.31499;
  unsigned char D.31500;
  struct MonoClass * D.31501;
  unsigned int D.31502;
  int D.31503;
  struct MonoType * D.31506;
  int D.31507;
  struct MonoInst * iftmp.83;
  int D.31513;
  int D.31514;
  unsigned int D.31515;
  sizetype D.31518;
  sizetype D.31519;
  sizetype D.31520;
  struct MonoInst * * D.31521;
  struct MonoInst * iftmp.84;
  int D.31524;
  unsigned int D.31525;
  sizetype D.31528;
  sizetype D.31529;
  struct MonoInst * * D.31530;
  _Bool D.31532;
  long int D.31533;
  long int D.31534;
  _Bool D.31537;
  long int D.31538;
  long int D.31539;
  unsigned char D.31542;
  unsigned char D.31543;
  unsigned char D.31544;
  unsigned char D.31545;
  struct MonoInst * * sp.85;
  struct MonoDebugOptions * D.31556;
  int D.31557;
  struct MonoDebugOptions * D.31565;
  int D.31566;
  struct MonoDebugOptions * D.31574;
  int D.31575;
  int D.31579;
  struct MonoType * D.31580;
  int D.31581;
  struct MonoDebugOptions * D.31588;
  int D.31589;
  struct MonoDebugOptions * D.31597;
  int D.31598;
  unsigned int D.31600;
  int D.31601;
  struct MonoInst * * sp.86;
  struct MonoDebugOptions * D.31612;
  int D.31613;
  unsigned int D.31615;
  int D.31616;
  struct MonoInst * * sp.87;
  struct MonoDebugOptions * D.31627;
  int D.31628;
  int D.31630;
  long int D.31631;
  unsigned int D.31632;
  int D.31633;
  struct MonoInst * * sp.88;
  struct MonoDebugOptions * D.31644;
  int D.31645;
  struct MonoDebugOptions * D.31653;
  int D.31654;
  signed char D.31656;
  long int D.31657;
  unsigned int D.31658;
  int D.31659;
  struct MonoInst * * sp.89;
  unsigned char * D.31664;
  struct MonoDebugOptions * D.31671;
  int D.31672;
  struct MonoDebugOptions * D.31680;
  int D.31681;
  unsigned int D.31683;
  unsigned int D.31684;
  unsigned int D.31685;
  unsigned int D.31686;
  unsigned int D.31687;
  unsigned int D.31688;
  unsigned int D.31689;
  unsigned int D.31690;
  unsigned int D.31691;
  unsigned int D.31692;
  int D.31693;
  long int D.31694;
  unsigned int D.31695;
  int D.31696;
  struct MonoInst * * sp.90;
  unsigned char * D.31701;
  struct MonoDebugOptions * D.31708;
  int D.31709;
  struct MonoDebugOptions * D.31717;
  int D.31718;
  unsigned int D.31720;
  int D.31721;
  long unsigned int D.31722;
  unsigned int D.31723;
  unsigned int D.31724;
  unsigned int D.31725;
  unsigned int D.31726;
  unsigned int D.31727;
  unsigned int D.31728;
  unsigned int D.31729;
  unsigned int D.31730;
  unsigned int D.31731;
  unsigned int D.31732;
  long unsigned int D.31733;
  long unsigned int D.31734;
  long unsigned int D.31735;
  unsigned int D.31736;
  unsigned int D.31737;
  unsigned int D.31738;
  unsigned int D.31739;
  unsigned int D.31740;
  unsigned int D.31741;
  unsigned int D.31742;
  unsigned int D.31743;
  unsigned int D.31744;
  unsigned int D.31745;
  long unsigned int D.31746;
  long unsigned int D.31747;
  long int D.31748;
  struct MonoInst * * sp.91;
  struct MonoDebugOptions * D.31759;
  int D.31760;
  struct MonoDebugOptions * D.31768;
  int D.31769;
  long int D.31773;
  struct MonoInst * D.31774;
  guint16 iftmp.92;
  int D.31779;
  int D.31780;
  unsigned int D.31781;
  int D.31782;
  unsigned int D.31786;
  int D.31787;
  unsigned int D.31792;
  int D.31793;
  unsigned int D.31797;
  unsigned int D.31798;
  unsigned int D.31799;
  unsigned int D.31800;
  unsigned int D.31801;
  unsigned int D.31802;
  unsigned int D.31803;
  unsigned int D.31804;
  unsigned int D.31805;
  unsigned int D.31806;
  float D.31807;
  struct MonoInst * * sp.93;
  struct MonoDebugOptions * D.31815;
  int D.31816;
  struct MonoDebugOptions * D.31824;
  int D.31825;
  long int D.31829;
  struct MonoInst * D.31830;
  guint16 iftmp.94;
  int D.31835;
  int D.31836;
  unsigned int D.31837;
  int D.31838;
  unsigned int D.31842;
  int D.31843;
  unsigned int D.31848;
  int D.31849;
  double D.31853;
  struct MonoInst * * sp.95;
  struct MonoDebugOptions * D.31861;
  int D.31862;
  struct MonoDebugOptions * D.31870;
  int D.31871;
  struct MonoType * D.31873;
  long int D.31874;
  struct MonoInst * D.31875;
  int D.31876;
  int D.31877;
  long int D.31878;
  long unsigned int D.31879;
  long unsigned int D.31880;
  struct MonoInst * * D.31881;
  struct MonoInst * D.31882;
  struct MonoType * D.31883;
  unsigned int D.31884;
  short unsigned int D.31885;
  struct MonoClass * D.31886;
  int D.31887;
  short unsigned int D.31888;
  struct MonoClass * D.31891;
  unsigned int D.31895;
  short unsigned int D.31896;
  unsigned int D.31897;
  int D.31898;
  struct MonoClass * D.31901;
  struct MonoInst * * sp.96;
  unsigned int D.31906;
  short unsigned int D.31907;
  unsigned int D.31908;
  int D.31909;
  struct MonoClass * D.31912;
  struct MonoInst * * sp.97;
  struct MonoDebugOptions * D.31923;
  int D.31924;
  const char * D.31934;
  const char * D.31935;
  const char * D.31936;
  struct MonoMethodSignature * D.31937;
  short unsigned int D.31938;
  int D.31939;
  const char * D.31940;
  gchar * D.31941;
  char * D.31944;
  struct MonoDebugOptions * D.31951;
  int D.31952;
  struct MonoDebugOptions * D.31960;
  int D.31961;
  struct MonoLoaderError * D.31966;
  struct MonoDebugOptions * D.31967;
  int D.31968;
  int D.31972;
  const char * D.31979;
  <unnamed type> D.31980;
  short unsigned int D.31986;
  int D.31987;
  <unnamed-unsigned:1> D.31988;
  int D.31989;
  int D.31992;
  int D.31993;
  struct MonoMethodSignature * D.31994;
  long unsigned int D.31995;
  unsigned int D.31996;
  unsigned int D.31997;
  void * D.31998;
  struct MonoInst * * D.31999;
  long unsigned int D.32000;
  long unsigned int D.32001;
  struct MonoInst * * D.32002;
  void * D.32003;
  struct MonoInst * D.32004;
  long int D.32005;
  struct MonoInst * D.32006;
  int D.32007;
  int D.32008;
  struct MonoType * * D.32009;
  struct MonoType * D.32010;
  unsigned int D.32011;
  short unsigned int D.32012;
  struct MonoInst * * D.32013;
  struct MonoInst * D.32014;
  struct MonoClass * D.32015;
  int D.32016;
  unsigned char D.32017;
  <unnamed type> D.32018;
  unsigned int D.32019;
  int D.32020;
  short unsigned int D.32021;
  struct MonoClass * D.32024;
  struct MonoInst * * D.32032;
  struct MonoInst * D.32033;
  unsigned char D.32034;
  unsigned char D.32035;
  unsigned int i.98;
  _Bool D.32040;
  _Bool D.32041;
  struct MonoDebugOptions * D.32048;
  int D.32049;
  struct MonoDebugOptions * D.32059;
  int D.32060;
  short unsigned int D.32062;
  int D.32063;
  <unnamed-unsigned:1> D.32064;
  int D.32065;
  long unsigned int D.32066;
  long unsigned int D.32069;
  long unsigned int D.32070;
  void * D.32073;
  struct MonoInst * D.32074;
  long int D.32075;
  struct MonoInst * D.32076;
  guint16 iftmp.99;
  int D.32081;
  int D.32082;
  unsigned int D.32083;
  int D.32084;
  void * D.32088;
  struct MonoInst * D.32089;
  long int D.32090;
  struct MonoInst * D.32091;
  int D.32092;
  int D.32093;
  unsigned int D.32094;
  int D.32095;
  char * D.32106;
  unsigned char D.32110;
  struct MonoMethod * cil_method.100;
  char * D.32116;
  int D.32122;
  struct MonoClass * D.32125;
  long unsigned int D.32126;
  long unsigned int D.32127;
  _Bool D.32128;
  long int D.32129;
  long int D.32130;
  struct MonoLoaderError * D.32136;
  struct MonoDebugOptions * D.32137;
  int D.32138;
  long unsigned int D.32142;
  struct MonoGenericContainer * D.32147;
  struct MonoGenericContext * D.32148;
  int D.32149;
  int D.32152;
  gchar * D.32155;
  <unnamed type> D.32156;
  short unsigned int D.32161;
  int D.32162;
  int D.32163;
  long unsigned int D.32168;
  int D.32171;
  long unsigned int D.32174;
  long unsigned int D.32175;
  long unsigned int D.32178;
  int D.32181;
  struct MonoDebugOptions * D.32184;
  int D.32185;
  short unsigned int D.32191;
  int D.32192;
  int D.32193;
  int D.32195;
  unsigned char D.32197;
  struct MonoDebugOptions * D.32200;
  int D.32201;
  int check_for_pending_exc.101;
  <unnamed-unsigned:1> D.32206;
  int D.32207;
  struct MonoType * D.32212;
  int D.32213;
  unsigned char D.32220;
  long int D.32223;
  long int D.32224;
  long unsigned int D.32225;
  long unsigned int D.32226;
  long unsigned int D.32227;
  unsigned int D.32228;
  unsigned int D.32229;
  long unsigned int D.32230;
  long unsigned int D.32231;
  <unnamed type> D.32232;
  int D.32235;
  long unsigned int D.32245;
  long unsigned int D.32246;
  struct MonoGenericContainer * D.32255;
  struct MonoDebugOptions * D.32262;
  int D.32263;
  int D.32269;
  _Bool D.32270;
  long int D.32271;
  long int D.32272;
  long int D.32275;
  struct MonoDebugOptions * D.32282;
  int D.32283;
  sizetype D.32285;
  int D.32288;
  struct MonoClass * D.32293;
  long unsigned int D.32295;
  long unsigned int D.32296;
  struct MonoImage * D.32301;
  struct MonoImage * D.32302;
  unsigned int D.32304;
  unsigned int D.32305;
  int D.32316;
  long unsigned int D.32318;
  long unsigned int D.32319;
  unsigned char D.32321;
  unsigned char D.32322;
  unsigned char D.32324;
  int D.32325;
  int D.32327;
  long unsigned int D.32329;
  struct MonoType * D.32332;
  int D.32333;
  int D.32335;
  int D.32336;
  int D.32339;
  struct MonoInst * D.32340;
  void * D.32342;
  struct MonoInst * D.32343;
  long int D.32344;
  struct MonoInst * D.32345;
  guint16 iftmp.102;
  int D.32350;
  int D.32351;
  unsigned int D.32352;
  int D.32353;
  int D.32357;
  struct MonoInst * D.32358;
  long unsigned int D.32361;
  unsigned int D.32364;
  int D.32365;
  long unsigned int D.32366;
  long unsigned int D.32367;
  long int D.32368;
  int D.32372;
  struct MonoClass * D.32375;
  struct MonoInst * D.32376;
  struct MonoInst * iftmp.103;
  struct MonoInst * * D.32378;
  struct MonoInst * D.32379;
  int D.32380;
  unsigned int D.32381;
  long unsigned int D.32384;
  long unsigned int D.32385;
  struct MonoInst * * D.32386;
  unsigned char D.32390;
  unsigned char D.32391;
  struct MonoClass * D.32392;
  unsigned int D.32393;
  int D.32394;
  struct MonoType * D.32397;
  int D.32398;
  struct MonoInst * iftmp.104;
  int D.32404;
  int D.32405;
  unsigned int D.32406;
  sizetype D.32409;
  sizetype D.32410;
  sizetype D.32411;
  struct MonoInst * * D.32412;
  struct MonoInst * iftmp.105;
  int D.32415;
  unsigned int D.32416;
  sizetype D.32419;
  sizetype D.32420;
  struct MonoInst * * D.32421;
  _Bool D.32423;
  long int D.32424;
  long int D.32425;
  _Bool D.32428;
  long int D.32429;
  long int D.32430;
  unsigned char D.32433;
  unsigned char D.32434;
  unsigned char D.32435;
  unsigned char D.32436;
  struct MonoInst * D.32440;
  int D.32441;
  void * D.32446;
  struct MonoInst * D.32447;
  long int D.32448;
  struct MonoInst * D.32449;
  int D.32450;
  int D.32451;
  unsigned int D.32452;
  int D.32453;
  void * D.32460;
  unsigned int D.32461;
  int D.32462;
  void * D.32466;
  long int D.32467;
  struct MonoInst * D.32468;
  int D.32469;
  int D.32470;
  unsigned int D.32471;
  int D.32472;
  int D.32476;
  struct MonoClass * D.32479;
  long int D.32486;
  struct MonoInst * D.32487;
  int D.32488;
  int D.32489;
  unsigned int D.32490;
  int D.32491;
  unsigned int D.32495;
  short unsigned int D.32496;
  int D.32497;
  unsigned int D.32498;
  int D.32499;
  const char * D.32505;
  gchar * D.32506;
  struct MonoClass * D.32514;
  struct MonoClass * D.32515;
  struct MonoType * D.32517;
  unsigned int D.32518;
  short unsigned int D.32519;
  unsigned int D.32520;
  int D.32521;
  int D.32525;
  struct MonoInst * D.32526;
  unsigned int D.32530;
  unsigned char D.32541;
  struct MonoDebugOptions * D.32542;
  int D.32543;
  struct MonoDebugOptions * D.32547;
  int D.32548;
  struct MonoDebugOptions * D.32554;
  int D.32555;
  struct MonoMethod * * D.32559;
  int D.32560;
  long unsigned int D.32561;
  long unsigned int D.32562;
  struct MonoMethod * * D.32563;
  unsigned int D.32566;
  short unsigned int D.32567;
  unsigned int D.32568;
  int D.32569;
  int D.32573;
  struct MonoInst * D.32574;
  int D.32578;
  struct MonoDebugOptions * D.32585;
  int D.32586;
  struct MonoClass * D.32590;
  struct MonoClass * D.32591;
  const char * D.32594;
  int D.32595;
  unsigned int D.32600;
  int D.32605;
  struct MonoGenericClass * D.32614;
  int D.32617;
  int D.32620;
  unsigned char D.32626;
  struct MonoDebugOptions * D.32627;
  int D.32628;
  struct MonoGenericInst * D.32643;
  int pass_vtable.107;
  struct MonoDebugOptions * D.32658;
  int D.32659;
  long int D.32661;
  struct MonoInst * D.32662;
  guint16 iftmp.108;
  int D.32667;
  int D.32668;
  void * iftmp.109;
  unsigned int D.32673;
  int D.32674;
  int pass_mrgctx.110;
  _Bool D.32681;
  long int D.32682;
  long int D.32683;
  struct MonoDebugOptions * D.32691;
  int D.32692;
  int D.32696;
  int D.32698;
  unsigned int D.32701;
  _Bool D.32708;
  long int D.32709;
  long int D.32710;
  _Bool D.32713;
  long int D.32714;
  long int D.32715;
  long int D.32724;
  struct MonoInst * D.32725;
  int D.32726;
  int D.32727;
  long int D.32731;
  struct MonoInst * D.32732;
  int D.32733;
  int D.32734;
  long int D.32740;
  struct MonoInst * D.32741;
  int D.32742;
  int D.32743;
  long int D.32747;
  struct MonoInst * D.32748;
  int D.32749;
  int D.32750;
  long unsigned int D.32767;
  short unsigned int D.32768;
  int D.32772;
  long unsigned int D.32773;
  _Bool D.32774;
  long int D.32775;
  long int D.32776;
  int D.32787;
  const char * D.32792;
  gchar * D.32793;
  _Bool D.32798;
  long int D.32799;
  long int D.32800;
  long unsigned int D.32805;
  _Bool D.32806;
  long int D.32807;
  long int D.32808;
  struct MonoType * D.32812;
  long int D.32813;
  struct MonoInst * D.32814;
  int D.32815;
  int D.32816;
  long int D.32817;
  long unsigned int D.32818;
  long unsigned int D.32819;
  struct MonoInst * * D.32820;
  struct MonoInst * D.32821;
  struct MonoType * D.32822;
  unsigned int D.32823;
  short unsigned int D.32824;
  struct MonoClass * D.32825;
  int D.32826;
  short unsigned int D.32827;
  struct MonoClass * D.32830;
  void * D.32834;
  struct MonoInst * D.32835;
  long int D.32836;
  struct MonoInst * D.32837;
  int D.32838;
  int D.32839;
  unsigned int D.32840;
  short unsigned int D.32841;
  unsigned char D.32842;
  <unnamed type> D.32843;
  unsigned int D.32844;
  int D.32845;
  short unsigned int D.32846;
  struct MonoClass * D.32849;
  struct MonoInst * D.32853;
  void * D.32854;
  struct MonoInst * D.32855;
  long int D.32856;
  struct MonoInst * D.32857;
  int D.32858;
  int D.32859;
  long int D.32860;
  long unsigned int D.32861;
  long unsigned int D.32862;
  struct MonoInst * * D.32863;
  struct MonoInst * D.32864;
  unsigned char D.32865;
  unsigned char D.32866;
  struct MonoClass * D.32867;
  unsigned int D.32868;
  int D.32869;
  struct MonoType * D.32872;
  int D.32873;
  struct MonoInst * iftmp.111;
  int D.32879;
  int D.32880;
  unsigned int D.32881;
  sizetype D.32884;
  sizetype D.32885;
  sizetype D.32886;
  struct MonoInst * * D.32887;
  struct MonoInst * iftmp.112;
  int D.32890;
  unsigned int D.32891;
  sizetype D.32894;
  sizetype D.32895;
  struct MonoInst * * D.32896;
  _Bool D.32898;
  long int D.32899;
  long int D.32900;
  _Bool D.32903;
  long int D.32904;
  long int D.32905;
  unsigned char D.32908;
  unsigned char D.32909;
  unsigned char D.32910;
  unsigned char D.32911;
  void * D.32915;
  long int D.32916;
  struct MonoInst * D.32917;
  int D.32918;
  int D.32919;
  unsigned int D.32920;
  short unsigned int D.32921;
  unsigned char D.32922;
  <unnamed type> D.32923;
  unsigned int D.32924;
  int D.32925;
  short unsigned int D.32926;
  struct MonoClass * D.32929;
  struct MonoClass * D.32935;
  int D.32938;
  struct MonoMethodSignature * D.32941;
  short unsigned int D.32942;
  long int D.32945;
  long unsigned int D.32946;
  long unsigned int D.32947;
  struct MonoBasicBlock * * D.32948;
  struct MonoDebugOptions * D.32958;
  int D.32959;
  unsigned int D.32961;
  unsigned int D.32962;
  int D.32963;
  unsigned char * D.32964;
  long int D.32967;
  long int D.32968;
  long unsigned int D.32969;
  long unsigned int D.32970;
  struct MonoBasicBlock * * D.32971;
  long unsigned int D.32972;
  long unsigned int D.32973;
  unsigned int D.32976;
  unsigned int D.32977;
  int D.32986;
  unsigned int D.32993;
  int D.33002;
  struct GList * D.33005;
  int D.33011;
  unsigned int D.33020;
  int D.33021;
  unsigned int D.33024;
  struct MonoMethodSignature * D.33041;
  struct MonoType * D.33042;
  int D.33043;
  long unsigned int D.33048;
  long unsigned int D.33049;
  struct MonoType * * D.33050;
  struct MonoType * D.33051;
  unsigned int D.33052;
  short unsigned int D.33053;
  struct MonoInst * * D.33054;
  struct MonoInst * D.33055;
  struct MonoClass * D.33056;
  struct MonoInst * * D.33057;
  struct MonoInst * D.33058;
  int D.33059;
  int D.33060;
  struct MonoClass * D.33063;
  struct MonoBasicBlock * * D.33070;
  int D.33071;
  int num_calls.113;
  int D.33075;
  int D.33079;
  long unsigned int D.33087;
  const char * D.33091;
  gchar * D.33092;
  int mono_use_imt.114;
  _Bool D.33098;
  long int D.33099;
  long int D.33100;
  unsigned char D.33107;
  const char * D.33112;
  gchar * D.33113;
  int D.33118;
  int D.33129;
  const char * D.33136;
  gchar * D.33137;
  int D.33152;
  int D.33154;
  int iftmp.115;
  _Bool D.33169;
  long int D.33170;
  long int D.33171;
  _Bool D.33174;
  long int D.33175;
  long int D.33176;
  long int D.33185;
  struct MonoInst * D.33186;
  int D.33187;
  int D.33188;
  long int D.33192;
  struct MonoInst * D.33193;
  int D.33194;
  int D.33195;
  long int D.33201;
  struct MonoInst * D.33202;
  int D.33203;
  int D.33204;
  long int D.33208;
  struct MonoInst * D.33209;
  int D.33210;
  int D.33211;
  _Bool D.33219;
  long int D.33220;
  long int D.33221;
  short unsigned int D.33240;
  long int D.33247;
  struct MonoInst * D.33248;
  long int D.33249;
  unsigned int info_type.116;
  unsigned int D.33251;
  <unnamed type> info_type.117;
  int D.33255;
  int D.33256;
  int D.33259;
  struct MonoInst * * D.33262;
  unsigned char D.33263;
  int D.33266;
  struct MonoType * D.33267;
  unsigned int D.33268;
  short unsigned int D.33269;
  int D.33270;
  int D.33271;
  struct MonoClass * D.33272;
  long unsigned int D.33278;
  short unsigned int D.33283;
  long int D.33285;
  int D.33287;
  unsigned int D.33290;
  short unsigned int D.33291;
  unsigned int D.33292;
  int D.33293;
  int D.33298;
  struct MonoClass * D.33301;
  long unsigned int D.33302;
  long unsigned int D.33303;
  struct MonoDebugOptions * D.33311;
  int D.33312;
  struct MonoInst * iftmp.118;
  unsigned int D.33322;
  int call_opcode.119;
  int D.33330;
  int D.33344;
  int D.33345;
  struct MonoMethodSignature * D.33346;
  struct MonoType * * D.33347;
  struct MonoType * D.33348;
  unsigned int D.33349;
  short unsigned int D.33350;
  struct MonoInst * * D.33351;
  struct MonoInst * D.33352;
  struct MonoClass * D.33353;
  struct MonoInst * * D.33354;
  struct MonoInst * D.33355;
  int D.33356;
  int D.33357;
  struct MonoClass * D.33360;
  struct MonoDebugOptions * D.33376;
  int D.33377;
  unsigned int D.33379;
  unsigned int D.33380;
  int D.33381;
  short int D.33387;
  struct MonoMethod * D.33394;
  struct MonoInst * iftmp.120;
  struct MonoDebugOptions * D.33416;
  int D.33417;
  unsigned int D.33419;
  unsigned int D.33420;
  int D.33421;
  int D.33429;
  _Bool D.33432;
  long int D.33433;
  long int D.33434;
  struct MonoInst * * sp.121;
  struct MonoInst * D.33440;
  struct MonoInst * * sp.122;
  long int D.33445;
  struct MonoInst * D.33446;
  int D.33447;
  int D.33448;
  int D.33449;
  _Bool D.33456;
  long int D.33457;
  long int D.33458;
  short int D.33467;
  struct MonoMethodSignature * D.33470;
  struct MonoDebugOptions * D.33477;
  int D.33478;
  int D.33483;
  struct MonoDebugOptions * D.33490;
  int D.33491;
  long int D.33493;
  struct MonoInst * D.33494;
  int D.33495;
  int D.33496;
  long int D.33497;
  long unsigned int D.33498;
  long unsigned int D.33499;
  struct MonoInst * * D.33500;
  struct MonoInst * D.33501;
  struct MonoType * D.33502;
  unsigned int D.33503;
  short unsigned int D.33504;
  struct MonoClass * D.33505;
  int D.33506;
  short unsigned int D.33507;
  struct MonoClass * D.33510;
  struct MonoInst * D.33515;
  struct MonoInst * D.33520;
  struct MonoMethodSignature * D.33523;
  struct MonoType * D.33524;
  _Bool D.33532;
  long int D.33533;
  long int D.33534;
  struct MonoDebugOptions * D.33543;
  int D.33544;
  int D.33549;
  struct MonoDebugOptions * D.33556;
  int D.33557;
  unsigned int D.33559;
  struct MonoInst * D.33562;
  long int D.33565;
  struct MonoInst * D.33566;
  int D.33567;
  int D.33568;
  unsigned int D.33569;
  short unsigned int D.33570;
  struct MonoClass * D.33571;
  int D.33572;
  short unsigned int D.33573;
  struct MonoClass * D.33576;
  long int D.33581;
  struct MonoInst * D.33582;
  int D.33583;
  int D.33584;
  int D.33585;
  unsigned char D.33586;
  <unnamed type> D.33587;
  unsigned int D.33588;
  int D.33589;
  int D.33593;
  struct MonoClass * D.33597;
  struct MonoDebugOptions * D.33605;
  int D.33606;
  struct MonoDebugOptions * D.33617;
  int D.33618;
  signed char D.33620;
  sizetype D.33621;
  sizetype D.33622;
  long int target.123;
  long int D.33624;
  long unsigned int D.33625;
  long unsigned int D.33626;
  struct MonoBasicBlock * * D.33627;
  struct MonoDebugOptions * D.33637;
  int D.33638;
  unsigned int D.33640;
  unsigned int D.33641;
  int D.33642;
  struct MonoDebugOptions * D.33653;
  int D.33654;
  struct MonoDebugOptions * D.33665;
  int D.33666;
  struct MonoDebugOptions * D.33674;
  int D.33675;
  short unsigned int D.33677;
  short unsigned int D.33678;
  sizetype D.33679;
  sizetype D.33680;
  long int D.33681;
  struct MonoInst * D.33682;
  int D.33683;
  int D.33684;
  unsigned char D.33685;
  struct MonoDebugOptions * D.33692;
  int D.33693;
  void * D.33695;
  struct MonoDebugOptions * D.33705;
  int D.33706;
  unsigned int D.33708;
  unsigned int D.33709;
  int D.33710;
  struct MonoBasicBlock * * D.33713;
  struct MonoBasicBlock * * D.33716;
  struct MonoDebugOptions * D.33727;
  int D.33728;
  unsigned int D.33730;
  unsigned int D.33731;
  int D.33732;
  struct MonoDebugOptions * D.33743;
  int D.33744;
  struct MonoDebugOptions * D.33758;
  int D.33759;
  int D.33761;
  sizetype D.33762;
  sizetype D.33763;
  struct MonoDebugOptions * D.33773;
  int D.33774;
  unsigned int D.33776;
  unsigned int D.33777;
  int D.33778;
  struct MonoDebugOptions * D.33789;
  int D.33790;
  unsigned char D.33795;
  _Bool D.33796;
  int iftmp.124;
  guint32 iftmp.125;
  sizetype D.33806;
  unsigned char * D.33807;
  struct MonoDebugOptions * D.33814;
  int D.33815;
  struct MonoDebugOptions * D.33823;
  int D.33824;
  struct MonoInst * * D.33828;
  struct MonoInst * D.33829;
  unsigned char D.33830;
  struct MonoDebugOptions * D.33836;
  int D.33837;
  sizetype iftmp.126;
  sizetype D.33843;
  struct MonoDebugOptions * D.33853;
  int D.33854;
  unsigned int D.33856;
  unsigned int D.33857;
  int D.33858;
  struct MonoDebugOptions * D.33870;
  int D.33871;
  unsigned int D.33873;
  unsigned int D.33874;
  int D.33875;
  struct MonoDebugOptions * D.33886;
  int D.33887;
  long int D.33889;
  struct MonoInst * D.33890;
  int D.33891;
  int D.33892;
  unsigned char D.33893;
  struct MonoDebugOptions * D.33900;
  int D.33901;
  guint16 iftmp.127;
  void * D.33913;
  struct MonoDebugOptions * D.33923;
  int D.33924;
  unsigned int D.33926;
  unsigned int D.33927;
  int D.33928;
  struct MonoDebugOptions * D.33940;
  int D.33941;
  unsigned int D.33943;
  unsigned int D.33944;
  int D.33945;
  struct MonoDebugOptions * D.33954;
  int D.33955;
  struct MonoDebugOptions * D.33963;
  int D.33964;
  long int D.33966;
  struct MonoInst * D.33967;
  int D.33968;
  int D.33969;
  unsigned char D.33970;
  struct MonoDebugOptions * D.33977;
  int D.33978;
  void * D.33980;
  struct MonoDebugOptions * D.33990;
  int D.33991;
  unsigned int D.33993;
  unsigned int D.33994;
  int D.33995;
  struct MonoDebugOptions * D.34010;
  int D.34011;
  unsigned int D.34013;
  unsigned int D.34014;
  int D.34015;
  struct MonoDebugOptions * D.34026;
  int D.34027;
  unsigned int D.34035;
  unsigned int D.34036;
  unsigned int D.34037;
  unsigned int D.34038;
  struct MonoDebugOptions * D.34045;
  int D.34046;
  struct MonoDebugOptions * D.34054;
  int D.34055;
  unsigned char D.34057;
  struct MonoDebugOptions * D.34066;
  int D.34067;
  long unsigned int D.34069;
  unsigned char * D.34070;
  struct MonoDebugOptions * D.34077;
  int D.34078;
  struct MonoDebugOptions * D.34089;
  int D.34090;
  unsigned int D.34092;
  unsigned int D.34093;
  int D.34094;
  unsigned char * D.34095;
  long int D.34098;
  long int D.34099;
  long unsigned int D.34100;
  long unsigned int D.34101;
  struct MonoBasicBlock * * D.34102;
  unsigned int D.34103;
  unsigned int D.34104;
  unsigned int D.34105;
  unsigned int D.34106;
  unsigned char * D.34107;
  long int D.34108;
  long int D.34109;
  long unsigned int D.34110;
  long unsigned int D.34111;
  struct MonoBasicBlock * * D.34112;
  struct MonoDebugOptions * D.34122;
  int D.34123;
  unsigned int D.34125;
  unsigned int D.34126;
  int D.34127;
  struct MonoBasicBlock * * D.34130;
  struct MonoBasicBlock * D.34131;
  unsigned int D.34132;
  unsigned int D.34133;
  struct MonoDebugOptions * D.34142;
  int D.34143;
  long int D.34145;
  struct MonoInst * D.34146;
  int D.34147;
  int D.34148;
  int D.34149;
  long int D.34153;
  struct MonoInst * D.34154;
  int D.34155;
  int D.34156;
  unsigned int D.34159;
  unsigned int D.34160;
  int D.34161;
  unsigned char * D.34165;
  long int D.34168;
  long int D.34169;
  long unsigned int D.34170;
  long unsigned int D.34171;
  struct MonoBasicBlock * * D.34172;
  short unsigned int D.34177;
  short unsigned int D.34178;
  short unsigned int D.34180;
  short unsigned int D.34182;
  struct MonoBasicBlock * * D.34183;
  struct MonoBasicBlock * * D.34184;
  struct MonoBasicBlock * D.34185;
  void * D.34195;
  struct MonoBasicBlock * * D.34196;
  struct MonoBasicBlock * * D.34197;
  long unsigned int D.34201;
  unsigned int D.34204;
  unsigned int D.34205;
  int D.34206;
  struct MonoClass * D.34228;
  long int D.34235;
  struct MonoInst * D.34236;
  int D.34237;
  int D.34238;
  long int D.34243;
  struct MonoInst * D.34244;
  int D.34245;
  int D.34246;
  long int D.34250;
  struct MonoInst * D.34251;
  int D.34252;
  int D.34253;
  long int D.34259;
  struct MonoInst * D.34260;
  guint16 iftmp.128;
  int D.34265;
  int D.34266;
  long int D.34274;
  struct MonoInst * D.34275;
  int D.34276;
  int D.34277;
  long int D.34281;
  struct MonoInst * D.34282;
  int D.34283;
  int D.34284;
  long int D.34288;
  struct MonoInst * D.34289;
  int D.34290;
  int D.34291;
  struct MonoDebugOptions * D.34301;
  int D.34302;
  unsigned int D.34304;
  unsigned int D.34305;
  unsigned int D.34306;
  unsigned int D.34307;
  int D.34308;
  short unsigned int D.34309;
  int D.34310;
  char D.34311;
  unsigned char D.34312;
  unsigned char D.34313;
  struct MonoInst * * sp.129;
  int D.34318;
  int D.34319;
  struct MonoDebugOptions * D.34328;
  int D.34329;
  int D.34331;
  short unsigned int D.34332;
  short unsigned int D.34346;
  void * D.34348;
  struct MonoDebugOptions * D.34355;
  int D.34356;
  struct MonoDebugOptions * D.34364;
  int D.34365;
  unsigned int D.34367;
  int D.34368;
  long int D.34371;
  int D.34372;
  int D.34375;
  short unsigned int D.34378;
  void * D.34379;
  struct MonoInst * * sp.130;
  struct MonoInst * D.34384;
  struct MonoDebugOptions * D.34391;
  int D.34392;
  struct MonoDebugOptions * D.34400;
  int D.34401;
  unsigned char D.34405;
  unsigned int D.34408;
  long int D.34409;
  struct MonoInst * D.34410;
  int D.34411;
  int D.34412;
  int D.34416;
  unsigned int D.34417;
  int D.34418;
  short unsigned int D.34419;
  long int iftmp.131;
  int D.34426;
  short unsigned int D.34431;
  long int D.34434;
  struct MonoInst * D.34436;
  struct MonoInst * * sp.132;
  struct MonoInst * D.34443;
  struct MonoDebugOptions * D.34450;
  int D.34451;
  short unsigned int D.34457;
  long int D.34459;
  unsigned int data.133;
  long int D.34463;
  long int D.34465;
  unsigned int D.34466;
  int D.34467;
  struct MonoDebugOptions * D.34474;
  int D.34475;
  unsigned int D.34477;
  int D.34478;
  struct MonoInst * * sp.134;
  struct MonoInst * D.34483;
  struct MonoDebugOptions * D.34490;
  int D.34491;
  struct MonoDebugOptions * D.34501;
  int D.34502;
  unsigned int D.34504;
  int D.34505;
  struct MonoInst * * sp.135;
  struct MonoInst * D.34510;
  struct MonoDebugOptions * D.34517;
  int D.34518;
  unsigned int D.34520;
  int D.34521;
  struct MonoInst * * sp.136;
  struct MonoInst * D.34526;
  struct MonoDebugOptions * D.34534;
  int D.34535;
  unsigned int D.34537;
  int D.34538;
  struct MonoInst * * sp.137;
  struct MonoInst * D.34543;
  struct MonoDebugOptions * D.34550;
  int D.34551;
  struct MonoDebugOptions * D.34561;
  int D.34562;
  unsigned int D.34564;
  int D.34565;
  struct MonoInst * * sp.138;
  struct MonoInst * D.34570;
  struct MonoDebugOptions * D.34577;
  int D.34578;
  unsigned int D.34580;
  int D.34581;
  struct MonoInst * * sp.139;
  struct MonoInst * D.34586;
  struct MonoDebugOptions * D.34594;
  int D.34595;
  unsigned int D.34597;
  int D.34598;
  struct MonoInst * * sp.140;
  struct MonoInst * D.34603;
  struct MonoDebugOptions * D.34610;
  int D.34611;
  struct MonoDebugOptions * D.34619;
  int D.34620;
  unsigned int D.34622;
  int D.34623;
  struct MonoInst * * sp.141;
  struct MonoInst * D.34628;
  struct MonoDebugOptions * D.34636;
  int D.34637;
  struct MonoDebugOptions * D.34645;
  int D.34646;
  unsigned int D.34652;
  long int D.34653;
  struct MonoInst * D.34654;
  int D.34655;
  int D.34656;
  int D.34660;
  unsigned int D.34661;
  int D.34662;
  struct MonoInst * * sp.142;
  struct MonoInst * D.34667;
  const char * D.34670;
  gchar * D.34671;
  struct MonoDebugOptions * D.34680;
  int D.34681;
  struct MonoDebugOptions * D.34689;
  int D.34690;
  struct MonoClass * klass.143;
  struct MonoClass * klass.144;
  unsigned char D.34697;
  struct MonoDebugOptions * D.34698;
  int D.34699;
  int D.34701;
  unsigned int D.34704;
  long int D.34705;
  struct MonoInst * D.34706;
  int D.34707;
  int D.34708;
  unsigned char D.34709;
  unsigned char D.34710;
  long int D.34714;
  struct MonoInst * D.34715;
  int D.34716;
  int D.34717;
  unsigned char D.34718;
  unsigned char D.34719;
  struct MonoDebugOptions * D.34734;
  int D.34735;
  struct MonoDebugOptions * D.34743;
  int D.34744;
  struct MonoClass * klass.145;
  struct MonoDebugOptions * D.34750;
  int D.34751;
  int D.34753;
  unsigned char * D.34754;
  unsigned char D.34755;
  int D.34758;
  unsigned int loc_index.146;
  struct MonoDebugOptions * D.34768;
  int D.34769;
  struct MonoType * D.34771;
  unsigned int D.34772;
  short unsigned int D.34773;
  unsigned int D.34774;
  int D.34775;
  long unsigned int D.34779;
  long unsigned int D.34780;
  struct MonoInst * * D.34781;
  struct MonoInst * D.34782;
  int D.34783;
  sizetype D.34784;
  int D.34787;
  unsigned int D.34790;
  unsigned int D.34791;
  unsigned int D.34792;
  unsigned int D.34793;
  unsigned int D.34794;
  unsigned int D.34795;
  unsigned int D.34796;
  unsigned int D.34797;
  unsigned int D.34798;
  unsigned int D.34799;
  int D.34802;
  struct MonoDebugOptions * D.34811;
  int D.34812;
  unsigned int D.34814;
  short unsigned int D.34815;
  unsigned int D.34816;
  int D.34817;
  struct MonoInst * * sp.147;
  struct MonoDebugOptions * D.34828;
  int D.34829;
  struct MonoDebugOptions * D.34837;
  int D.34838;
  unsigned int n.148;
  void * D.34843;
  unsigned int D.34844;
  int D.34845;
  void * D.34852;
  struct MonoInst * D.34853;
  long int D.34854;
  struct MonoInst * D.34855;
  int D.34856;
  int D.34857;
  void * D.34858;
  unsigned int D.34859;
  int D.34860;
  struct MonoInst * D.34864;
  struct GList * D.34870;
  void * D.34871;
  struct GList * D.34872;
  void * D.34877;
  struct MonoInst * D.34878;
  long int D.34879;
  struct MonoInst * D.34880;
  int D.34881;
  int D.34882;
  long int D.34883;
  long unsigned int D.34884;
  long unsigned int D.34885;
  struct MonoInst * * D.34886;
  struct MonoInst * D.34887;
  struct MonoType * D.34888;
  unsigned int D.34889;
  short unsigned int D.34890;
  struct MonoClass * D.34891;
  int D.34892;
  unsigned char D.34893;
  <unnamed type> D.34894;
  unsigned int D.34895;
  int D.34896;
  short unsigned int D.34897;
  struct MonoClass * D.34900;
  void * D.34901;
  unsigned int D.34902;
  int D.34903;
  void * D.34907;
  struct MonoInst * D.34908;
  long int D.34909;
  struct MonoInst * D.34910;
  guint16 iftmp.149;
  int D.34915;
  int D.34916;
  unsigned int D.34917;
  int D.34918;
  void * D.34922;
  struct MonoInst * D.34923;
  long int D.34924;
  struct MonoInst * D.34925;
  int D.34926;
  int D.34927;
  long int D.34928;
  long int D.34929;
  unsigned int D.34930;
  int D.34931;
  struct MonoInst * D.34935;
  unsigned int n.150;
  unsigned int D.34937;
  long unsigned int D.34939;
  long unsigned int D.34940;
  void * D.34945;
  struct MonoInst * D.34946;
  long int D.34947;
  struct MonoInst * D.34948;
  int D.34949;
  int D.34950;
  unsigned int D.34951;
  int D.34952;
  struct MonoInst * D.34956;
  void * D.34958;
  guint16 iftmp.151;
  unsigned int D.34963;
  int D.34964;
  void * D.34968;
  struct MonoInst * D.34969;
  long int D.34970;
  struct MonoInst * D.34971;
  int D.34972;
  int D.34973;
  unsigned int D.34974;
  int D.34975;
  struct MonoInst * D.34979;
  struct MonoJumpInfoToken * D.34983;
  struct MonoClass * D.34984;
  unsigned int D.34985;
  int D.34986;
  unsigned int D.34991;
  int D.34992;
  struct MonoString * D.34993;
  void * D.34994;
  struct MonoDebugOptions * D.35006;
  int D.35007;
  struct MonoLoaderError * D.35012;
  struct MonoDebugOptions * D.35013;
  int D.35014;
  struct MonoDebugOptions * D.35018;
  int D.35019;
  int D.35021;
  struct MonoDebugOptions * D.35024;
  int D.35025;
  <unnamed type> D.35029;
  int D.35032;
  <unnamed type> D.35043;
  int D.35054;
  int D.35057;
  struct MonoDebugOptions * D.35063;
  int D.35064;
  int D.35068;
  int D.35071;
  struct MonoGenericContext * D.35077;
  struct MonoGenericInst * D.35078;
  struct MonoDebugOptions * D.35083;
  int D.35084;
  struct MonoDebugOptions * D.35092;
  int D.35093;
  long int D.35095;
  struct MonoInst * D.35096;
  guint16 iftmp.152;
  int D.35101;
  int D.35102;
  void * iftmp.153;
  unsigned int D.35107;
  int D.35108;
  short unsigned int D.35112;
  struct MonoDebugOptions * D.35119;
  int D.35120;
  int D.35129;
  struct MonoType * D.35135;
  long unsigned int D.35136;
  long unsigned int D.35137;
  struct MonoType * D.35139;
  long unsigned int D.35140;
  long unsigned int D.35141;
  _Bool D.35142;
  long int D.35143;
  long int D.35144;
  void * D.35147;
  struct MonoInst * D.35148;
  long int D.35149;
  struct MonoInst * D.35150;
  int D.35151;
  int D.35152;
  unsigned int D.35153;
  long int D.35154;
  unsigned int D.35155;
  int D.35156;
  struct MonoInst * * sp.154;
  struct MonoInst * D.35161;
  struct MonoInst * * sp.155;
  struct MonoInst * D.35163;
  struct MonoInst * D.35164;
  struct MonoInst * * sp.156;
  struct MonoInst * D.35166;
  int n.157;
  int D.35168;
  struct MonoDebugOptions * D.35175;
  int D.35176;
  int D.35178;
  struct MonoInst * D.35183;
  int D.35196;
  _Bool D.35200;
  long int D.35201;
  long int D.35202;
  void * D.35207;
  unsigned int D.35208;
  int D.35209;
  struct MonoType * D.35216;
  struct MonoInst * D.35217;
  struct MonoInst * D.35218;
  int D.35219;
  void * D.35220;
  long int D.35221;
  long unsigned int D.35222;
  long unsigned int D.35223;
  struct MonoInst * * D.35224;
  struct MonoInst * D.35225;
  unsigned char D.35226;
  unsigned char D.35227;
  struct MonoClass * D.35228;
  unsigned int D.35229;
  int D.35230;
  struct MonoType * D.35233;
  int D.35234;
  struct MonoInst * iftmp.158;
  int D.35240;
  int D.35241;
  unsigned int D.35242;
  sizetype D.35245;
  sizetype D.35246;
  sizetype D.35247;
  struct MonoInst * * D.35248;
  struct MonoInst * iftmp.159;
  int D.35251;
  unsigned int D.35252;
  sizetype D.35255;
  sizetype D.35256;
  struct MonoInst * * D.35257;
  _Bool D.35259;
  long int D.35260;
  long int D.35261;
  _Bool D.35264;
  long int D.35265;
  long int D.35266;
  unsigned char D.35269;
  unsigned char D.35270;
  unsigned char D.35271;
  unsigned char D.35272;
  struct MonoDebugOptions * D.35285;
  int D.35286;
  int D.35288;
  struct GSList * D.35291;
  struct MonoMethodSignature * helper_sig_class_init_trampoline.160;
  const char * D.35297;
  const char * D.35298;
  long int D.35302;
  struct MonoInst * D.35303;
  int D.35304;
  int D.35305;
  int D.35306;
  struct MonoType * D.35317;
  int D.35318;
  int D.35329;
  struct MonoClass * D.35331;
  int D.35332;
  struct GList * D.35334;
  int D.35338;
  int D.35348;
  const char * D.35353;
  gchar * D.35354;
  int D.35360;
  int D.35366;
  int D.35368;
  unsigned int D.35377;
  short unsigned int D.35378;
  unsigned int D.35379;
  int D.35380;
  struct MonoClass * D.35383;
  struct MonoClass * D.35387;
  struct MonoType * D.35388;
  struct MonoInst * * sp.161;
  struct MonoInst * * sp.162;
  struct MonoDebugOptions * D.35398;
  int D.35399;
  struct MonoDebugOptions * D.35407;
  int D.35408;
  struct MonoClass * klass.163;
  struct MonoDebugOptions * D.35414;
  int D.35415;
  struct MonoDebugOptions * D.35423;
  int D.35424;
  int D.35429;
  void * D.35431;
  struct MonoInst * D.35432;
  long int D.35433;
  struct MonoInst * D.35434;
  guint16 iftmp.164;
  int D.35439;
  int D.35440;
  unsigned int D.35441;
  int D.35442;
  void * D.35448;
  struct MonoInst * D.35449;
  long int D.35450;
  struct MonoInst * D.35451;
  guint16 iftmp.165;
  int D.35456;
  int D.35457;
  unsigned int D.35458;
  int D.35459;
  void * D.35464;
  void * D.35465;
  unsigned int D.35466;
  int D.35467;
  struct MonoInst * * sp.166;
  struct MonoInst * D.35472;
  long unsigned int D.35477;
  long unsigned int D.35478;
  unsigned int D.35480;
  unsigned int D.35481;
  struct MonoMethodSignature * D.35482;
  _Bool D.35484;
  long int D.35485;
  long int D.35486;
  struct MonoInst * * sp.167;
  struct MonoInst * D.35490;
  struct MonoInst * * sp.168;
  struct MonoDebugOptions * D.35499;
  int D.35500;
  struct MonoDebugOptions * D.35508;
  int D.35509;
  struct MonoClass * klass.169;
  struct MonoDebugOptions * D.35515;
  int D.35516;
  struct MonoDebugOptions * D.35524;
  int D.35525;
  int D.35530;
  void * D.35532;
  struct MonoInst * D.35533;
  long int D.35534;
  struct MonoInst * D.35535;
  guint16 iftmp.170;
  int D.35540;
  int D.35541;
  unsigned int D.35542;
  int D.35543;
  void * D.35549;
  struct MonoInst * D.35550;
  long int D.35551;
  struct MonoInst * D.35552;
  guint16 iftmp.171;
  int D.35557;
  int D.35558;
  unsigned int D.35559;
  int D.35560;
  void * D.35565;
  void * D.35566;
  unsigned int D.35567;
  int D.35568;
  struct MonoInst * * sp.172;
  struct MonoInst * D.35573;
  struct MonoMethodSignature * D.35579;
  _Bool D.35581;
  long int D.35582;
  long int D.35583;
  struct MonoInst * * sp.173;
  struct MonoInst * D.35587;
  struct MonoInst * * sp.174;
  struct MonoDebugOptions * D.35596;
  int D.35597;
  struct MonoDebugOptions * D.35605;
  int D.35606;
  struct MonoClass * klass.175;
  struct MonoDebugOptions * D.35612;
  int D.35613;
  int D.35615;
  struct MonoInst * D.35618;
  int D.35619;
  int D.35625;
  void * D.35627;
  struct MonoInst * D.35628;
  long int D.35629;
  struct MonoInst * D.35630;
  guint16 iftmp.176;
  int D.35635;
  int D.35636;
  unsigned int D.35637;
  int D.35638;
  void * D.35644;
  struct MonoInst * D.35645;
  long int D.35646;
  struct MonoInst * D.35647;
  guint16 iftmp.177;
  int D.35652;
  int D.35653;
  unsigned int D.35654;
  int D.35655;
  void * D.35660;
  void * D.35661;
  unsigned int D.35662;
  int D.35663;
  struct MonoInst * * sp.178;
  struct MonoInst * D.35668;
  struct MonoMethodSignature * D.35674;
  _Bool D.35676;
  long int D.35677;
  long int D.35678;
  struct MonoInst * * sp.179;
  struct MonoInst * D.35682;
  struct MonoInst * * sp.180;
  int D.35685;
  struct MonoInst * * sp.181;
  unsigned int D.35689;
  short unsigned int D.35690;
  unsigned int D.35691;
  int D.35692;
  struct MonoInst * * sp.182;
  struct MonoDebugOptions * D.35703;
  int D.35704;
  struct MonoDebugOptions * D.35712;
  int D.35713;
  struct MonoClass * klass.183;
  struct MonoDebugOptions * D.35719;
  int D.35720;
  int D.35722;
  struct MonoInst * * sp.184;
  struct MonoClass * D.35726;
  struct MonoDebugOptions * D.35733;
  int D.35734;
  int D.35736;
  struct MonoDebugOptions * D.35743;
  int D.35744;
  int D.35748;
  int D.35753;
  int iftmp.185;
  char * D.35766;
  struct MonoDebugOptions * D.35773;
  int D.35774;
  struct MonoDebugOptions * D.35782;
  int D.35783;
  struct MonoDebugOptions * D.35794;
  int D.35795;
  unsigned int D.35797;
  unsigned int D.35798;
  int D.35799;
  unsigned char * D.35800;
  long int D.35803;
  long int D.35804;
  long unsigned int D.35805;
  long unsigned int D.35806;
  struct MonoBasicBlock * * D.35807;
  struct MonoDebugOptions * D.35817;
  int D.35818;
  unsigned int D.35820;
  unsigned int D.35821;
  int D.35822;
  unsigned char * D.35823;
  long int D.35826;
  long int D.35827;
  long unsigned int D.35828;
  long unsigned int D.35829;
  struct MonoBasicBlock * * D.35830;
  struct MonoDebugOptions * D.35839;
  int D.35840;
  unsigned int D.35844;
  long int D.35845;
  struct MonoInst * D.35846;
  int D.35847;
  int D.35848;
  long int D.35852;
  struct MonoInst * D.35853;
  int D.35854;
  int D.35855;
  _Bool D.35856;
  int D.35857;
  long int D.35858;
  long int D.35862;
  struct MonoInst * D.35863;
  int D.35864;
  int D.35865;
  void * D.35866;
  struct MonoBasicBlock * * D.35867;
  struct MonoBasicBlock * * D.35868;
  struct MonoBasicBlock * iftmp.186;
  struct MonoInst * * sp.187;
  struct MonoInst * D.35881;
  struct MonoDebugOptions * D.35889;
  int D.35890;
  struct MonoDebugOptions * D.35898;
  int D.35899;
  struct MonoClass * klass.188;
  struct MonoDebugOptions * D.35905;
  int D.35906;
  int D.35908;
  void * iftmp.189;
  int D.35912;
  unsigned int D.35913;
  long unsigned int D.35916;
  long unsigned int D.35917;
  struct MonoInst * * D.35918;
  struct MonoInst * iftmp.190;
  struct MonoInst * iftmp.191;
  unsigned char D.35928;
  unsigned char D.35929;
  struct MonoInst * iftmp.192;
  struct MonoClass * D.35934;
  unsigned int D.35935;
  int D.35936;
  struct MonoInst * iftmp.193;
  struct MonoType * D.35943;
  int D.35944;
  struct MonoInst * iftmp.194;
  struct MonoInst * iftmp.195;
  int D.35954;
  int D.35955;
  unsigned int D.35956;
  struct MonoInst * iftmp.196;
  int D.35963;
  sizetype D.35964;
  sizetype D.35965;
  sizetype D.35966;
  struct MonoInst * * D.35967;
  struct MonoInst * iftmp.197;
  struct MonoInst * iftmp.198;
  int D.35974;
  int D.35975;
  unsigned int D.35976;
  struct MonoInst * iftmp.199;
  int D.35983;
  sizetype D.35984;
  sizetype D.35985;
  sizetype D.35986;
  struct MonoInst * * D.35987;
  _Bool D.35989;
  long int D.35990;
  long int D.35991;
  _Bool D.35994;
  long int D.35995;
  long int D.35996;
  unsigned char D.35999;
  unsigned char D.36000;
  unsigned char D.36001;
  unsigned char D.36002;
  struct MonoInst * * sp.200;
  struct MonoInst * * sp.201;
  unsigned int op.202;
  unsigned int D.36010;
  _Bool D.36011;
  struct MonoDebugOptions * D.36022;
  int D.36023;
  struct MonoDebugOptions * D.36032;
  int D.36033;
  unsigned char D.36037;
  struct MonoDebugOptions * D.36043;
  int D.36044;
  struct MonoDebugOptions * D.36054;
  int D.36055;
  struct MonoDebugOptions * D.36066;
  int D.36067;
  struct MonoDebugOptions * D.36075;
  int D.36076;
  struct MonoClass * klass.203;
  struct MonoDebugOptions * D.36084;
  int D.36085;
  int D.36091;
  gchar * D.36094;
  int D.36099;
  struct MonoDebugOptions * D.36106;
  int D.36107;
  <unnamed type> D.36111;
  struct MonoType * D.36116;
  short unsigned int D.36117;
  int D.36118;
  int D.36119;
  guint iftmp.204;
  long unsigned int D.36123;
  int D.36126;
  unsigned int D.36127;
  int D.36131;
  struct MonoDebugOptions * D.36138;
  int D.36139;
  struct MonoMethodSignature * D.36146;
  long unsigned int D.36147;
  long unsigned int D.36148;
  int D.36151;
  long unsigned int D.36152;
  struct MonoClass * D.36154;
  const char * D.36157;
  gchar * D.36158;
  void * D.36161;
  struct MonoInst * D.36162;
  long int D.36163;
  struct MonoInst * D.36164;
  guint16 iftmp.205;
  int D.36169;
  int D.36170;
  unsigned int D.36171;
  int D.36172;
  void * D.36176;
  struct MonoInst * D.36177;
  long int D.36178;
  struct MonoInst * D.36179;
  guint16 iftmp.206;
  int D.36184;
  int D.36185;
  unsigned int D.36186;
  int D.36187;
  void * D.36191;
  struct MonoInst * D.36192;
  long int D.36193;
  struct MonoInst * D.36194;
  int D.36195;
  int D.36196;
  mgreg_t iftmp.207;
  long unsigned int D.36200;
  long unsigned int D.36201;
  unsigned int D.36203;
  int D.36204;
  struct MonoMethodSignature * D.36212;
  _Bool D.36214;
  long int D.36215;
  long int D.36216;
  long int D.36221;
  struct MonoInst * D.36222;
  int D.36223;
  int D.36224;
  long int D.36228;
  struct MonoInst * D.36229;
  int D.36230;
  int D.36231;
  int D.36236;
  unsigned int D.36239;
  int D.36240;
  long int D.36244;
  struct MonoInst * D.36245;
  unsigned int D.36246;
  short unsigned int D.36247;
  int D.36248;
  int D.36249;
  struct MonoClass * D.36250;
  unsigned int D.36255;
  short unsigned int D.36256;
  long int D.36257;
  struct MonoClass * D.36258;
  unsigned char D.36264;
  unsigned char D.36265;
  unsigned int D.36270;
  unsigned int D.36274;
  long int D.36275;
  struct MonoInst * D.36276;
  int D.36277;
  int D.36278;
  unsigned char D.36282;
  struct MonoMethodSignature * D.36289;
  long unsigned int D.36290;
  long unsigned int D.36291;
  struct MonoMethod * iftmp.208;
  const char * D.36301;
  gchar * D.36302;
  void * D.36305;
  struct MonoInst * D.36306;
  long int D.36307;
  struct MonoInst * D.36308;
  guint16 iftmp.209;
  int D.36313;
  int D.36314;
  unsigned int D.36315;
  int D.36316;
  void * D.36320;
  struct MonoInst * D.36321;
  long int D.36322;
  struct MonoInst * D.36323;
  guint16 iftmp.210;
  int D.36328;
  int D.36329;
  unsigned int D.36330;
  int D.36331;
  void * D.36335;
  struct MonoInst * D.36336;
  long int D.36337;
  struct MonoInst * D.36338;
  int D.36339;
  int D.36340;
  mgreg_t iftmp.211;
  unsigned int D.36345;
  int D.36346;
  struct MonoMethodSignature * D.36354;
  struct MonoInst * * sp.212;
  struct MonoInst * D.36359;
  struct MonoInst * * sp.213;
  struct MonoInst * iftmp.214;
  unsigned int D.36366;
  long unsigned int D.36369;
  long unsigned int D.36370;
  struct MonoInst * * D.36371;
  struct MonoClass * D.36376;
  _Bool D.36377;
  long int D.36378;
  long int D.36379;
  unsigned char D.36382;
  unsigned char D.36383;
  unsigned int D.36384;
  int D.36385;
  struct MonoType * D.36388;
  int D.36389;
  struct MonoInst * iftmp.215;
  int D.36395;
  int D.36396;
  unsigned int D.36397;
  sizetype D.36400;
  sizetype D.36401;
  sizetype D.36402;
  struct MonoInst * * D.36403;
  struct MonoInst * iftmp.216;
  int D.36406;
  unsigned int D.36407;
  sizetype D.36410;
  sizetype D.36411;
  struct MonoInst * * D.36412;
  _Bool D.36414;
  long int D.36415;
  long int D.36416;
  _Bool D.36419;
  long int D.36420;
  long int D.36421;
  unsigned char D.36424;
  unsigned char D.36425;
  unsigned char D.36426;
  unsigned char D.36427;
  int D.36433;
  const char * D.36438;
  gchar * D.36439;
  struct MonoInst * * sp.217;
  struct MonoInst * D.36443;
  long int D.36447;
  struct MonoInst * D.36448;
  int D.36449;
  int D.36450;
  long int D.36454;
  struct MonoInst * D.36455;
  int D.36456;
  int D.36457;
  unsigned int D.36461;
  int D.36462;
  int D.36465;
  struct MonoClass * D.36473;
  struct MonoInst * * sp.218;
  long int D.36478;
  struct MonoInst * D.36479;
  int D.36480;
  int D.36481;
  long int D.36485;
  struct MonoInst * D.36486;
  int D.36487;
  int D.36488;
  int D.36493;
  unsigned int D.36496;
  int D.36497;
  long int D.36501;
  struct MonoInst * D.36502;
  unsigned int D.36503;
  short unsigned int D.36504;
  int D.36505;
  int D.36506;
  unsigned char D.36507;
  <unnamed type> D.36508;
  unsigned int D.36509;
  int D.36510;
  unsigned int D.36515;
  short unsigned int D.36516;
  unsigned int D.36517;
  int D.36518;
  unsigned char D.36522;
  unsigned char D.36523;
  unsigned char D.36526;
  struct MonoInst * * sp.219;
  short unsigned int D.36530;
  int D.36531;
  int D.36532;
  struct MonoDebugOptions * D.36539;
  int D.36540;
  struct MonoDebugOptions * D.36549;
  int D.36550;
  union mono_mutex_t * D.36552;
  _Bool D.36555;
  long int D.36556;
  long int D.36557;
  struct GHashTable * D.36560;
  _Bool D.36565;
  long int D.36566;
  long int D.36567;
  long unsigned int addr.220;
  long unsigned int D.36574;
  const char * D.36585;
  gchar * D.36586;
  unsigned int D.36592;
  long int D.36593;
  struct MonoInst * D.36594;
  int D.36595;
  int D.36596;
  int D.36597;
  guint16 iftmp.221;
  unsigned int D.36607;
  int D.36608;
  long int D.36612;
  struct MonoInst * D.36613;
  int D.36614;
  int D.36615;
  unsigned int D.36619;
  long int D.36620;
  struct MonoInst * D.36621;
  int D.36622;
  int D.36623;
  long int D.36627;
  struct MonoInst * D.36628;
  int D.36629;
  int D.36630;
  long int D.36634;
  struct MonoInst * D.36635;
  int D.36636;
  int D.36637;
  long int D.36641;
  struct MonoInst * D.36642;
  int D.36643;
  int D.36644;
  unsigned int D.36648;
  long int D.36649;
  struct MonoInst * D.36650;
  int D.36651;
  int D.36652;
  unsigned int D.36656;
  long int D.36657;
  struct MonoInst * D.36658;
  int D.36659;
  int D.36660;
  unsigned int D.36664;
  long int addr.222;
  unsigned int D.36670;
  unsigned int D.36671;
  unsigned int D.36672;
  unsigned int D.36673;
  long int D.36674;
  struct MonoInst * D.36675;
  int D.36676;
  int D.36677;
  long unsigned int D.36678;
  long unsigned int D.36679;
  long int D.36680;
  unsigned int D.36684;
  long int D.36685;
  long int D.36686;
  _Bool D.36697;
  long int D.36698;
  long int D.36699;
  void * D.36706;
  struct MonoInst * D.36707;
  long int D.36708;
  struct MonoInst * D.36709;
  int D.36710;
  int D.36711;
  long int D.36712;
  long unsigned int D.36713;
  long unsigned int D.36714;
  struct MonoInst * * D.36715;
  struct MonoInst * D.36716;
  struct MonoType * D.36717;
  unsigned int D.36718;
  short unsigned int D.36719;
  struct MonoClass * D.36720;
  int D.36721;
  unsigned char D.36722;
  <unnamed type> D.36723;
  unsigned int D.36724;
  int D.36725;
  short unsigned int D.36726;
  struct MonoClass * D.36729;
  void * D.36730;
  unsigned int D.36731;
  int D.36732;
  struct MonoInst * D.36738;
  void * D.36740;
  struct MonoInst * D.36741;
  long int D.36742;
  struct MonoInst * D.36743;
  guint16 iftmp.223;
  int D.36748;
  int D.36749;
  unsigned int D.36750;
  int D.36751;
  int D.36757;
  int D.36760;
  unsigned int D.36763;
  int D.36764;
  int D.36765;
  unsigned int D.36773;
  long int D.36774;
  void * D.36790;
  struct MonoInst * D.36791;
  long int D.36792;
  struct MonoInst * D.36793;
  int D.36794;
  int D.36795;
  long int D.36796;
  long unsigned int D.36797;
  long unsigned int D.36798;
  struct MonoInst * * D.36799;
  struct MonoInst * D.36800;
  struct MonoType * D.36801;
  unsigned int D.36802;
  short unsigned int D.36803;
  struct MonoClass * D.36804;
  int D.36805;
  unsigned char D.36806;
  <unnamed type> D.36807;
  unsigned int D.36808;
  int D.36809;
  short unsigned int D.36810;
  struct MonoClass * D.36813;
  void * D.36814;
  unsigned int D.36815;
  int D.36816;
  void * D.36820;
  struct MonoInst * D.36821;
  long int D.36822;
  struct MonoInst * D.36823;
  guint16 iftmp.224;
  int D.36828;
  int D.36829;
  unsigned int D.36830;
  int D.36831;
  struct MonoDebugOptions * D.36840;
  int D.36841;
  int D.36845;
  struct GSList * D.36848;
  const char * D.36853;
  const char * D.36854;
  const char * D.36855;
  long unsigned int D.36857;
  _Bool D.36860;
  long int D.36861;
  long int D.36862;
  long unsigned int D.36865;
  long unsigned int D.36866;
  guint16 iftmp.225;
  unsigned int D.36883;
  int D.36884;
  void * D.36891;
  sizetype D.36892;
  _Bool D.36893;
  long int D.36894;
  long int D.36895;
  unsigned int D.36898;
  int D.36899;
  void * D.36904;
  struct MonoInst * D.36905;
  long int D.36906;
  struct MonoInst * D.36907;
  int D.36908;
  int D.36909;
  unsigned int D.36910;
  long int D.36911;
  unsigned int D.36912;
  int D.36913;
  struct MonoClass * D.36919;
  struct MonoInst * * sp.226;
  long int D.36924;
  struct MonoInst * D.36925;
  unsigned int D.36926;
  short unsigned int D.36927;
  int D.36928;
  int D.36929;
  int D.36930;
  struct MonoClass * D.36931;
  unsigned char D.36935;
  unsigned char D.36936;
  struct MonoDebugOptions * D.36943;
  int D.36944;
  int D.36948;
  long unsigned int D.36955;
  long unsigned int D.36956;
  unsigned char D.36957;
  void * D.36960;
  struct MonoClass * D.36963;
  long unsigned int D.36964;
  long unsigned int D.36965;
  struct MonoType * D.36968;
  unsigned char D.36969;
  const char * D.36972;
  gchar * D.36973;
  void * D.36976;
  unsigned char D.36977;
  long int D.36978;
  unsigned int D.36979;
  int D.36980;
  void * D.36984;
  signed char D.36985;
  long int D.36986;
  unsigned int D.36987;
  int D.36988;
  void * D.36992;
  short unsigned int D.36993;
  long int D.36994;
  unsigned int D.36995;
  int D.36996;
  void * D.37000;
  short int D.37001;
  long int D.37002;
  unsigned int D.37003;
  int D.37004;
  void * D.37008;
  int D.37009;
  long int D.37010;
  unsigned int D.37011;
  int D.37012;
  void * D.37016;
  unsigned int D.37017;
  long int D.37018;
  unsigned int D.37019;
  int D.37020;
  void * D.37024;
  void * D.37025;
  unsigned int D.37026;
  int D.37027;
  int D.37031;
  void * D.37034;
  unsigned int D.37035;
  int D.37036;
  void * D.37041;
  unsigned int D.37042;
  int D.37043;
  long int D.37044;
  struct MonoDebugOptions * D.37056;
  int D.37057;
  long int D.37059;
  struct MonoInst * D.37060;
  unsigned int D.37061;
  short unsigned int D.37062;
  int D.37063;
  int D.37064;
  unsigned char D.37065;
  <unnamed type> D.37066;
  unsigned int D.37067;
  int D.37068;
  unsigned char D.37072;
  unsigned char D.37073;
  struct MonoInst * * sp.227;
  struct MonoDebugOptions * D.37081;
  int D.37082;
  struct MonoDebugOptions * D.37090;
  int D.37091;
  struct MonoClass * klass.228;
  struct MonoDebugOptions * D.37097;
  int D.37098;
  unsigned int D.37100;
  short unsigned int D.37101;
  struct MonoClass * D.37102;
  int D.37110;
  struct MonoDebugOptions * D.37119;
  int D.37120;
  struct MonoDebugOptions * D.37128;
  int D.37129;
  struct MonoClass * klass.229;
  struct MonoDebugOptions * D.37135;
  int D.37136;
  unsigned char D.37138;
  unsigned int D.37141;
  int D.37142;
  struct MonoInst * D.37146;
  struct MonoInst * D.37149;
  void * D.37160;
  struct MonoInst * D.37161;
  long int D.37162;
  struct MonoInst * D.37163;
  int D.37164;
  int D.37165;
  long int D.37166;
  long unsigned int D.37167;
  long unsigned int D.37168;
  struct MonoInst * * D.37169;
  struct MonoInst * D.37170;
  struct MonoType * D.37171;
  unsigned int D.37172;
  short unsigned int D.37173;
  struct MonoClass * D.37174;
  int D.37175;
  unsigned char D.37176;
  <unnamed type> D.37177;
  unsigned int D.37178;
  int D.37179;
  short unsigned int D.37180;
  struct MonoClass * D.37183;
  void * D.37184;
  unsigned int D.37185;
  int D.37186;
  void * D.37190;
  struct MonoInst * D.37191;
  long int D.37192;
  struct MonoInst * D.37193;
  guint16 iftmp.230;
  int D.37198;
  int D.37199;
  unsigned int D.37200;
  int D.37201;
  unsigned char D.37209;
  struct MonoDebugOptions * D.37210;
  int D.37211;
  unsigned int D.37213;
  int D.37214;
  unsigned int D.37218;
  struct MonoInst * * sp.231;
  int D.37224;
  short unsigned int D.37227;
  long int D.37230;
  unsigned int D.37231;
  unsigned int D.37234;
  void * D.37235;
  struct MonoInst * D.37236;
  long int D.37237;
  struct MonoInst * D.37238;
  int D.37239;
  int D.37240;
  void * D.37246;
  struct MonoInst * D.37247;
  long int D.37248;
  struct MonoInst * D.37249;
  int D.37250;
  int D.37251;
  unsigned int field_token.232;
  struct MonoJumpInfoToken * D.37253;
  unsigned int D.37254;
  int D.37255;
  void * D.37260;
  unsigned int D.37261;
  int D.37262;
  void * D.37266;
  struct MonoInst * D.37267;
  long int D.37268;
  struct MonoInst * D.37269;
  int D.37270;
  int D.37271;
  int data_size.233;
  long int D.37273;
  unsigned int D.37274;
  int D.37275;
  struct MonoDebugOptions * D.37285;
  int D.37286;
  struct MonoDebugOptions * D.37294;
  int D.37295;
  unsigned int D.37297;
  int D.37298;
  unsigned char D.37299;
  struct MonoInst * * sp.234;
  struct MonoDebugOptions * D.37310;
  int D.37311;
  struct MonoDebugOptions * D.37319;
  int D.37320;
  struct MonoDebugOptions * D.37328;
  int D.37329;
  unsigned int D.37331;
  struct MonoClass * klass.235;
  struct MonoDebugOptions * D.37336;
  int D.37337;
  unsigned char D.37348;
  struct MonoDebugOptions * D.37349;
  int D.37350;
  struct MonoInst * * sp.236;
  struct MonoDebugOptions * D.37359;
  int D.37360;
  struct MonoDebugOptions * D.37370;
  int D.37371;
  struct MonoClass * klass.237;
  struct MonoDebugOptions * D.37377;
  int D.37378;
  struct MonoClass * klass.238;
  struct MonoDebugOptions * D.37388;
  int D.37389;
  int D.37391;
  unsigned int D.37394;
  short unsigned int D.37395;
  int D.37396;
  unsigned int D.37397;
  int D.37398;
  int D.37405;
  unsigned int D.37406;
  unsigned int D.37407;
  unsigned int D.37408;
  unsigned int D.37409;
  unsigned int D.37410;
  unsigned int D.37413;
  long int D.37418;
  struct MonoInst * D.37419;
  int D.37420;
  int D.37421;
  long int D.37425;
  struct MonoInst * D.37426;
  int D.37427;
  int D.37428;
  unsigned int D.37435;
  int D.37438;
  long int D.37443;
  struct MonoInst * D.37444;
  int D.37445;
  int D.37446;
  long int D.37450;
  struct MonoInst * D.37451;
  int D.37452;
  int D.37453;
  long int D.37458;
  struct MonoInst * D.37459;
  int D.37460;
  int D.37461;
  unsigned char D.37462;
  int D.37467;
  long int D.37472;
  struct MonoInst * D.37473;
  int D.37474;
  int D.37475;
  long int D.37479;
  struct MonoInst * D.37480;
  int D.37481;
  int D.37482;
  long int D.37487;
  struct MonoInst * D.37488;
  int D.37489;
  int D.37490;
  unsigned char D.37491;
  long int D.37495;
  struct MonoInst * D.37496;
  int D.37497;
  int D.37498;
  long int D.37502;
  struct MonoInst * D.37503;
  int D.37504;
  int D.37505;
  unsigned int D.37510;
  int D.37513;
  long int D.37518;
  struct MonoInst * D.37519;
  int D.37520;
  int D.37521;
  long int D.37525;
  struct MonoInst * D.37526;
  int D.37527;
  int D.37528;
  long int D.37533;
  struct MonoInst * D.37534;
  int D.37535;
  int D.37536;
  unsigned char D.37537;
  int D.37542;
  long int D.37547;
  struct MonoInst * D.37548;
  int D.37549;
  int D.37550;
  long int D.37554;
  struct MonoInst * D.37555;
  int D.37556;
  int D.37557;
  long int D.37562;
  struct MonoInst * D.37563;
  int D.37564;
  int D.37565;
  unsigned char D.37566;
  long int D.37570;
  struct MonoInst * D.37571;
  int D.37572;
  int D.37573;
  long int D.37577;
  struct MonoInst * D.37578;
  int D.37579;
  int D.37580;
  long int D.37585;
  struct MonoInst * D.37586;
  int D.37587;
  int D.37588;
  unsigned char D.37589;
  unsigned char D.37590;
  unsigned int D.37594;
  short unsigned int D.37595;
  long int D.37596;
  unsigned int D.37597;
  int D.37598;
  unsigned int D.37603;
  short unsigned int D.37604;
  unsigned int D.37605;
  int D.37606;
  struct MonoInst * * sp.239;
  struct MonoDebugOptions * D.37620;
  int D.37621;
  struct MonoDebugOptions * D.37631;
  int D.37632;
  struct MonoClass * klass.240;
  struct MonoDebugOptions * D.37638;
  int D.37639;
  struct MonoClass * klass.241;
  struct MonoDebugOptions * D.37649;
  int D.37650;
  struct MonoDebugOptions * D.37661;
  int D.37662;
  unsigned int D.37664;
  int D.37665;
  struct MonoInst * * sp.242;
  struct MonoInst * D.37670;
  unsigned int D.37671;
  unsigned int D.37672;
  const char * D.37675;
  gchar * D.37676;
  struct MonoDebugOptions * D.37685;
  int D.37686;
  struct MonoDebugOptions * D.37694;
  int D.37695;
  struct MonoClass * klass.243;
  struct MonoDebugOptions * D.37701;
  int D.37702;
  struct MonoInst * iftmp.244;
  struct MonoClass * D.37710;
  struct MonoType * D.37711;
  long int D.37712;
  struct MonoInst * D.37713;
  int D.37714;
  int D.37715;
  unsigned char D.37716;
  unsigned char D.37717;
  struct MonoClass * D.37718;
  unsigned int D.37719;
  int D.37720;
  struct MonoType * D.37723;
  int D.37724;
  struct MonoInst * iftmp.245;
  int D.37730;
  int D.37731;
  unsigned int D.37732;
  sizetype D.37735;
  sizetype D.37736;
  sizetype D.37737;
  struct MonoInst * * D.37738;
  struct MonoInst * iftmp.246;
  int D.37741;
  unsigned int D.37742;
  sizetype D.37745;
  sizetype D.37746;
  struct MonoInst * * D.37747;
  _Bool D.37749;
  long int D.37750;
  long int D.37751;
  _Bool D.37754;
  long int D.37755;
  long int D.37756;
  unsigned char D.37759;
  unsigned char D.37760;
  unsigned char D.37761;
  unsigned char D.37762;
  long int D.37766;
  struct MonoInst * D.37767;
  int D.37768;
  int D.37769;
  int D.37770;
  long int D.37776;
  struct MonoInst * D.37777;
  int D.37778;
  int D.37779;
  int D.37780;
  long int D.37784;
  struct MonoInst * D.37785;
  int D.37786;
  int D.37787;
  struct MonoInst * * sp.247;
  const char * D.37798;
  gchar * D.37799;
  struct MonoDebugOptions * D.37808;
  int D.37809;
  struct MonoDebugOptions * D.37817;
  int D.37818;
  struct MonoClass * klass.248;
  struct MonoDebugOptions * D.37824;
  int D.37825;
  long int D.37827;
  struct MonoInst * D.37828;
  int D.37829;
  int D.37830;
  long int D.37831;
  long unsigned int D.37832;
  long unsigned int D.37833;
  struct MonoInst * * D.37834;
  struct MonoInst * D.37835;
  unsigned char D.37836;
  unsigned char D.37837;
  struct MonoClass * D.37838;
  unsigned int D.37839;
  int D.37840;
  struct MonoType * D.37843;
  int D.37844;
  struct MonoInst * iftmp.249;
  int D.37850;
  int D.37851;
  unsigned int D.37852;
  sizetype D.37855;
  sizetype D.37856;
  sizetype D.37857;
  struct MonoInst * * D.37858;
  struct MonoInst * iftmp.250;
  int D.37861;
  unsigned int D.37862;
  sizetype D.37865;
  sizetype D.37866;
  struct MonoInst * * D.37867;
  _Bool D.37869;
  long int D.37870;
  long int D.37871;
  _Bool D.37874;
  long int D.37875;
  long int D.37876;
  unsigned char D.37879;
  unsigned char D.37880;
  unsigned char D.37881;
  unsigned char D.37882;
  unsigned int D.37888;
  long int D.37889;
  struct MonoInst * D.37890;
  int D.37891;
  int D.37892;
  int D.37893;
  int D.37894;
  long int D.37898;
  struct MonoInst * D.37899;
  int D.37900;
  int D.37901;
  long int D.37905;
  struct MonoInst * D.37906;
  int D.37907;
  int D.37908;
  unsigned int D.37915;
  unsigned int D.37916;
  long int D.37917;
  struct MonoInst * D.37918;
  guint16 iftmp.251;
  int D.37923;
  int D.37924;
  long int D.37928;
  struct MonoInst * D.37929;
  int D.37930;
  int D.37931;
  long int D.37935;
  struct MonoInst * D.37936;
  int D.37937;
  int D.37938;
  long int D.37942;
  struct MonoInst * D.37943;
  int D.37944;
  int D.37945;
  long int D.37950;
  struct MonoInst * D.37951;
  int D.37952;
  int D.37953;
  long int D.37954;
  long int D.37958;
  struct MonoInst * D.37959;
  int D.37960;
  int D.37961;
  long int klass.252;
  long int D.37966;
  struct MonoInst * D.37967;
  int D.37968;
  int D.37969;
  unsigned int D.37973;
  short unsigned int D.37974;
  unsigned int D.37975;
  int D.37976;
  struct MonoClass * D.37979;
  struct MonoInst * * sp.253;
  struct MonoDebugOptions * D.37990;
  int D.37991;
  struct MonoDebugOptions * D.37999;
  int D.38000;
  int D.38006;
  unsigned int D.38007;
  void * handle_class.254;
  struct MonoClass * D.38009;
  struct MonoClass * handle_class.255;
  struct MonoDebugOptions * D.38015;
  int D.38016;
  int D.38020;
  unsigned int D.38021;
  unsigned int D.38022;
  int D.38028;
  struct MonoClass * D.38032;
  struct MonoClass * D.38034;
  struct MonoClass * D.38037;
  struct MonoClass * D.38039;
  struct MonoType * D.38048;
  void * D.38049;
  struct MonoInst * D.38050;
  long int D.38051;
  struct MonoInst * D.38052;
  guint16 iftmp.256;
  int D.38057;
  int D.38058;
  unsigned int D.38059;
  int D.38060;
  void * D.38064;
  struct MonoInst * D.38065;
  long int D.38066;
  struct MonoInst * D.38067;
  int D.38068;
  int D.38069;
  unsigned int D.38070;
  int D.38071;
  struct MonoInst * D.38077;
  void * D.38079;
  struct MonoInst * D.38080;
  long int D.38081;
  struct MonoInst * D.38082;
  int D.38083;
  int D.38084;
  unsigned int D.38085;
  int D.38086;
  long int D.38090;
  struct MonoInst * D.38091;
  int D.38092;
  int D.38093;
  long int D.38094;
  long unsigned int D.38095;
  long unsigned int D.38096;
  struct MonoInst * * D.38097;
  struct MonoInst * D.38098;
  unsigned char D.38099;
  unsigned char D.38100;
  struct MonoClass * D.38101;
  unsigned int D.38102;
  int D.38103;
  struct MonoType * D.38106;
  int D.38107;
  struct MonoInst * iftmp.257;
  int D.38113;
  int D.38114;
  unsigned int D.38115;
  sizetype D.38118;
  sizetype D.38119;
  sizetype D.38120;
  struct MonoInst * * D.38121;
  struct MonoInst * iftmp.258;
  int D.38124;
  unsigned int D.38125;
  sizetype D.38128;
  sizetype D.38129;
  struct MonoInst * * D.38130;
  _Bool D.38132;
  long int D.38133;
  long int D.38134;
  _Bool D.38137;
  long int D.38138;
  long int D.38139;
  unsigned char D.38142;
  unsigned char D.38143;
  unsigned char D.38144;
  unsigned char D.38145;
  long int D.38149;
  struct MonoInst * D.38150;
  int D.38151;
  int D.38152;
  int D.38153;
  unsigned int D.38157;
  short unsigned int D.38158;
  unsigned int D.38159;
  int D.38160;
  struct MonoClass * D.38163;
  int D.38171;
  struct MonoClass * D.38175;
  int D.38177;
  struct MonoImage * D.38188;
  unsigned int D.38189;
  struct MonoClass * D.38190;
  struct MonoJumpInfoToken * D.38193;
  struct MonoClass * D.38194;
  unsigned int D.38195;
  int D.38196;
  unsigned int D.38202;
  int D.38203;
  struct MonoJumpInfoToken * D.38208;
  unsigned int D.38209;
  int D.38210;
  struct MonoReflectionType * D.38215;
  unsigned int D.38216;
  int D.38217;
  struct MonoClass * D.38225;
  struct MonoJumpInfoToken * D.38236;
  unsigned int D.38237;
  int D.38238;
  unsigned int D.38243;
  int D.38244;
  long int D.38248;
  struct MonoInst * D.38249;
  int D.38250;
  int D.38251;
  long int D.38252;
  long unsigned int D.38253;
  long unsigned int D.38254;
  struct MonoInst * * D.38255;
  struct MonoInst * D.38256;
  unsigned char D.38257;
  unsigned char D.38258;
  struct MonoClass * D.38259;
  unsigned int D.38260;
  int D.38261;
  struct MonoType * D.38264;
  int D.38265;
  struct MonoInst * iftmp.259;
  int D.38271;
  int D.38272;
  unsigned int D.38273;
  sizetype D.38276;
  sizetype D.38277;
  sizetype D.38278;
  struct MonoInst * * D.38279;
  struct MonoInst * iftmp.260;
  int D.38282;
  unsigned int D.38283;
  sizetype D.38286;
  sizetype D.38287;
  struct MonoInst * * D.38288;
  _Bool D.38290;
  long int D.38291;
  long int D.38292;
  _Bool D.38295;
  long int D.38296;
  long int D.38297;
  unsigned char D.38300;
  unsigned char D.38301;
  unsigned char D.38302;
  unsigned char D.38303;
  long int D.38307;
  struct MonoInst * D.38308;
  int D.38309;
  int D.38310;
  int D.38311;
  unsigned int D.38315;
  short unsigned int D.38316;
  unsigned int D.38317;
  int D.38318;
  struct MonoClass * D.38321;
  struct MonoInst * * sp.261;
  struct MonoDebugOptions * D.38332;
  int D.38333;
  struct MonoDebugOptions * D.38354;
  int D.38355;
  sizetype D.38357;
  sizetype D.38358;
  struct MonoDebugOptions * D.38366;
  int D.38367;
  signed char D.38369;
  sizetype D.38370;
  sizetype D.38371;
  unsigned int D.38372;
  long int D.38373;
  unsigned int D.38376;
  unsigned int D.38377;
  long int D.38378;
  unsigned int D.38381;
  long int iftmp.262;
  long int D.38388;
  unsigned int D.38393;
  unsigned int D.38394;
  int D.38395;
  long int D.38396;
  struct MonoInst * D.38397;
  int D.38398;
  int D.38399;
  int D.38400;
  long int D.38404;
  struct MonoInst * D.38405;
  int D.38406;
  int D.38407;
  unsigned int D.38410;
  unsigned int D.38411;
  int D.38412;
  unsigned char * D.38416;
  long int D.38419;
  long int D.38420;
  long unsigned int D.38421;
  long unsigned int D.38422;
  struct MonoBasicBlock * * D.38423;
  void * D.38439;
  struct MonoBasicBlock * * D.38440;
  struct MonoBasicBlock * * D.38441;
  unsigned int D.38447;
  unsigned int D.38448;
  int D.38449;
  long int D.38467;
  struct MonoInst * D.38468;
  int D.38469;
  int D.38470;
  unsigned char * D.38474;
  long int D.38477;
  long int D.38478;
  long unsigned int D.38479;
  long unsigned int D.38480;
  struct MonoBasicBlock * * D.38481;
  unsigned int D.38498;
  long unsigned int D.38499;
  long unsigned int D.38500;
  struct MonoBasicBlock * * D.38501;
  _Bool D.38502;
  long int D.38503;
  long int D.38504;
  struct MonoDebugOptions * D.38521;
  int D.38522;
  unsigned int D.38524;
  unsigned int D.38525;
  int D.38526;
  unsigned char * D.38527;
  long int D.38530;
  long int D.38531;
  long unsigned int D.38532;
  long unsigned int D.38533;
  struct MonoBasicBlock * * D.38534;
  struct MonoDebugOptions * D.38547;
  int D.38548;
  unsigned int D.38550;
  unsigned int D.38551;
  int D.38552;
  _Bool D.38558;
  long int D.38559;
  long int D.38560;
  struct MonoDebugOptions * D.38569;
  int D.38570;
  unsigned int D.38572;
  unsigned int D.38573;
  unsigned int D.38574;
  unsigned int D.38575;
  unsigned int D.38576;
  unsigned int D.38577;
  unsigned int D.38578;
  unsigned int D.38579;
  unsigned int D.38580;
  char * D.38583;
  _Bool D.38584;
  long int D.38585;
  long int D.38586;
  struct MonoMethodSignature * D.38589;
  short unsigned int D.38590;
  long int D.38591;
  struct MonoDebugOptions * D.38598;
  int D.38599;
  long unsigned int D.38601;
  long unsigned int D.38602;
  sizetype D.38603;
  const void * D.38604;
  struct MonoType * D.38605;
  int D.38606;
  struct MonoInst * * sp.263;
  int num_calls.264;
  int D.38611;
  struct MonoDebugOptions * D.38618;
  int D.38619;
  struct MonoDebugOptions * D.38627;
  int D.38628;
  gint32 * D.38632;
  guint16 iftmp.265;
  unsigned int D.38639;
  int D.38640;
  struct MonoInst * * sp.266;
  unsigned int D.38645;
  int D.38646;
  struct MonoInst * * sp.267;
  int num_calls.268;
  int D.38652;
  struct MonoDebugOptions * D.38661;
  int D.38662;
  struct MonoDebugOptions * D.38670;
  int D.38671;
  _Bool D.38673;
  long int D.38674;
  long int D.38675;
  guint16 iftmp.269;
  const char * D.38682;
  unsigned int D.38683;
  int D.38684;
  struct MonoInst * * sp.270;
  int num_calls.271;
  int D.38690;
  struct MonoDebugOptions * D.38697;
  int D.38698;
  struct MonoDebugOptions * D.38706;
  int D.38707;
  guint16 iftmp.272;
  unsigned int D.38715;
  int D.38716;
  _Bool D.38721;
  long int D.38722;
  long int D.38723;
  unsigned int D.38726;
  int D.38727;
  struct MonoInst * * sp.273;
  struct MonoDebugOptions * D.38738;
  int D.38739;
  struct MonoInst * iftmp.274;
  long int D.38745;
  struct MonoInst * D.38746;
  int D.38747;
  int D.38748;
  unsigned char D.38749;
  unsigned char D.38750;
  struct MonoClass * D.38751;
  unsigned int D.38752;
  int D.38753;
  struct MonoType * D.38756;
  int D.38757;
  struct MonoInst * iftmp.275;
  int D.38763;
  int D.38764;
  unsigned int D.38765;
  sizetype D.38768;
  sizetype D.38769;
  sizetype D.38770;
  struct MonoInst * * D.38771;
  struct MonoInst * iftmp.276;
  int D.38774;
  unsigned int D.38775;
  sizetype D.38778;
  sizetype D.38779;
  struct MonoInst * * D.38780;
  _Bool D.38782;
  long int D.38783;
  long int D.38784;
  _Bool D.38787;
  long int D.38788;
  long int D.38789;
  unsigned char D.38792;
  unsigned char D.38793;
  unsigned char D.38794;
  unsigned char D.38795;
  struct MonoInst * * sp.277;
  struct MonoDebugOptions * D.38806;
  int D.38807;
  struct MonoDebugOptions * D.38815;
  int D.38816;
  void * klass.278;
  void * D.38823;
  struct MonoInst * D.38824;
  long int D.38825;
  struct MonoInst * D.38826;
  int D.38827;
  int D.38828;
  long int D.38829;
  long unsigned int D.38830;
  long unsigned int D.38831;
  struct MonoInst * * D.38832;
  struct MonoInst * D.38833;
  struct MonoType * D.38834;
  unsigned int D.38835;
  short unsigned int D.38836;
  struct MonoClass * D.38837;
  int D.38838;
  unsigned char D.38839;
  <unnamed type> D.38840;
  unsigned int D.38841;
  int D.38842;
  short unsigned int D.38843;
  struct MonoClass * D.38846;
  void * D.38847;
  unsigned int D.38848;
  int D.38849;
  void * D.38853;
  struct MonoInst * D.38854;
  long int D.38855;
  struct MonoInst * D.38856;
  guint16 iftmp.279;
  int D.38861;
  int D.38862;
  unsigned int D.38863;
  int D.38864;
  struct MonoInst * * sp.280;
  struct MonoInst * D.38869;
  int num_calls.281;
  int D.38871;
  struct MonoDebugOptions * D.38878;
  int D.38879;
  unsigned int D.38881;
  int D.38882;
  struct MonoInst * * sp.282;
  struct MonoDebugOptions * D.38893;
  int D.38894;
  struct MonoDebugOptions * D.38902;
  int D.38903;
  void * klass.283;
  _Bool D.38906;
  long int D.38907;
  long int D.38908;
  long int D.38911;
  struct MonoInst * D.38912;
  int D.38913;
  int D.38914;
  long int D.38915;
  long unsigned int D.38916;
  long unsigned int D.38917;
  struct MonoInst * * D.38918;
  struct MonoInst * D.38919;
  unsigned char D.38920;
  unsigned char D.38921;
  struct MonoClass * D.38922;
  unsigned int D.38923;
  int D.38924;
  struct MonoType * D.38927;
  int D.38928;
  struct MonoInst * iftmp.284;
  int D.38934;
  int D.38935;
  unsigned int D.38936;
  sizetype D.38939;
  sizetype D.38940;
  sizetype D.38941;
  struct MonoInst * * D.38942;
  struct MonoInst * iftmp.285;
  int D.38945;
  unsigned int D.38946;
  sizetype D.38949;
  sizetype D.38950;
  struct MonoInst * * D.38951;
  _Bool D.38953;
  long int D.38954;
  long int D.38955;
  _Bool D.38958;
  long int D.38959;
  long int D.38960;
  unsigned char D.38963;
  unsigned char D.38964;
  unsigned char D.38965;
  unsigned char D.38966;
  unsigned int D.38970;
  short unsigned int D.38971;
  unsigned char D.38972;
  <unnamed type> D.38973;
  unsigned int D.38974;
  int D.38975;
  short unsigned int D.38976;
  struct MonoClass * D.38979;
  struct MonoInst * * sp.286;
  _Bool D.38984;
  long int D.38985;
  long int D.38986;
  struct MonoMethodSignature * D.38989;
  long unsigned int D.38990;
  long unsigned int D.38991;
  _Bool D.38992;
  long int D.38993;
  long int D.38994;
  struct MonoDebugOptions * D.39003;
  int D.39004;
  struct MonoDebugOptions * D.39012;
  int D.39013;
  void * klass.287;
  long unsigned int D.39018;
  _Bool D.39019;
  long int D.39020;
  long int D.39021;
  unsigned char D.39024;
  unsigned char D.39025;
  unsigned int D.39026;
  int D.39027;
  struct MonoType * D.39030;
  int D.39031;
  struct MonoInst * iftmp.288;
  int D.39037;
  unsigned int D.39038;
  sizetype D.39041;
  sizetype D.39042;
  sizetype D.39043;
  struct MonoInst * * D.39044;
  struct MonoInst * iftmp.289;
  int D.39047;
  unsigned int D.39048;
  sizetype D.39051;
  sizetype D.39052;
  struct MonoInst * * D.39053;
  _Bool D.39055;
  long int D.39056;
  long int D.39057;
  _Bool D.39060;
  long int D.39061;
  long int D.39062;
  unsigned char D.39065;
  unsigned char D.39066;
  unsigned char D.39067;
  unsigned char D.39068;
  unsigned int D.39073;
  int D.39074;
  struct MonoDebugOptions * D.39084;
  int D.39085;
  struct MonoDebugOptions * D.39096;
  int D.39097;
  struct MonoDebugOptions * D.39105;
  int D.39106;
  unsigned int D.39108;
  unsigned int token.290;
  void * klass.291;
  struct MonoInst * * sp.292;
  struct MonoDebugOptions * D.39121;
  int D.39122;
  struct MonoDebugOptions * D.39130;
  int D.39131;
  guint16 iftmp.293;
  void * D.39137;
  unsigned int D.39138;
  int D.39139;
  struct MonoInst * * sp.294;
  int num_calls.295;
  int D.39145;
  struct MonoDebugOptions * D.39152;
  int D.39153;
  struct MonoDebugOptions * D.39161;
  int D.39162;
  _Bool D.39164;
  long int D.39165;
  long int D.39166;
  <unnamed type> key.296;
  unsigned int D.39176;
  int D.39177;
  struct MonoInst * * sp.297;
  struct MonoInst * D.39183;
  struct MonoInst * D.39186;
  unsigned char D.39187;
  unsigned char D.39188;
  int D.39189;
  int D.39190;
  unsigned int D.39194;
  int num_calls.298;
  int D.39196;
  struct MonoDebugOptions * D.39203;
  int D.39204;
  struct MonoInst * D.39206;
  unsigned int D.39207;
  int D.39208;
  long int D.39212;
  struct MonoInst * D.39213;
  int D.39214;
  int D.39215;
  struct MonoInst * D.39216;
  int D.39217;
  unsigned int D.39225;
  unsigned int D.39226;
  int D.39227;
  long int D.39231;
  struct MonoInst * D.39232;
  int D.39233;
  int D.39234;
  int D.39235;
  long int D.39239;
  struct MonoInst * D.39240;
  int D.39241;
  int D.39242;
  unsigned int D.39245;
  unsigned int D.39246;
  int D.39247;
  unsigned char * D.39251;
  long int D.39254;
  long int D.39255;
  long unsigned int D.39256;
  long unsigned int D.39257;
  struct MonoBasicBlock * * D.39258;
  void * D.39274;
  struct MonoBasicBlock * * D.39275;
  struct MonoBasicBlock * * D.39276;
  unsigned int D.39282;
  unsigned int D.39283;
  int D.39284;
  long int D.39305;
  struct MonoInst * D.39306;
  int D.39307;
  int D.39308;
  int D.39309;
  long int D.39313;
  struct MonoInst * D.39314;
  int D.39315;
  int D.39316;
  unsigned int D.39319;
  unsigned int D.39320;
  int D.39321;
  unsigned char * D.39325;
  long int D.39328;
  long int D.39329;
  long unsigned int D.39330;
  long unsigned int D.39331;
  struct MonoBasicBlock * * D.39332;
  void * D.39348;
  struct MonoBasicBlock * * D.39349;
  struct MonoBasicBlock * * D.39350;
  unsigned int D.39356;
  unsigned int D.39357;
  int D.39358;
  void * D.39378;
  struct MonoInst * D.39379;
  long int D.39380;
  struct MonoInst * D.39381;
  int D.39382;
  int D.39383;
  unsigned int D.39384;
  int D.39385;
  void * D.39390;
  unsigned int D.39391;
  int D.39392;
  long int D.39396;
  struct MonoInst * D.39397;
  int D.39398;
  int D.39399;
  unsigned char * D.39405;
  long int D.39408;
  long int D.39409;
  long unsigned int D.39410;
  long unsigned int D.39411;
  struct MonoBasicBlock * * D.39412;
  unsigned int D.39427;
  void * D.39428;
  struct MonoInst * D.39429;
  long int D.39430;
  struct MonoInst * D.39431;
  int D.39432;
  int D.39433;
  struct MonoDebugOptions * D.39443;
  int D.39444;
  struct MonoDebugOptions * D.39452;
  int D.39453;
  struct MonoClass * D.39455;
  struct MonoType * D.39456;
  long int D.39457;
  struct MonoInst * D.39458;
  int D.39459;
  int D.39460;
  long int D.39461;
  long unsigned int D.39462;
  long unsigned int D.39463;
  struct MonoInst * * D.39464;
  struct MonoInst * D.39465;
  unsigned char D.39466;
  unsigned char D.39467;
  struct MonoClass * D.39468;
  unsigned int D.39469;
  int D.39470;
  struct MonoType * D.39473;
  int D.39474;
  struct MonoInst * iftmp.299;
  int D.39480;
  int D.39481;
  unsigned int D.39482;
  sizetype D.39485;
  sizetype D.39486;
  sizetype D.39487;
  struct MonoInst * * D.39488;
  struct MonoInst * iftmp.300;
  int D.39491;
  unsigned int D.39492;
  sizetype D.39495;
  sizetype D.39496;
  struct MonoInst * * D.39497;
  _Bool D.39499;
  long int D.39500;
  long int D.39501;
  _Bool D.39504;
  long int D.39505;
  long int D.39506;
  unsigned char D.39509;
  unsigned char D.39510;
  unsigned char D.39511;
  unsigned char D.39512;
  int D.39516;
  unsigned int D.39520;
  short unsigned int D.39521;
  unsigned int D.39522;
  int D.39523;
  struct MonoClass * D.39526;
  struct MonoInst * * sp.301;
  struct MonoDebugOptions * D.39537;
  int D.39538;
  long int D.39540;
  struct MonoInst * D.39541;
  short unsigned int D.39542;
  short unsigned int D.39543;
  int D.39544;
  int D.39545;
  short unsigned int D.39546;
  unsigned char D.39547;
  struct MonoDebugOptions * D.39554;
  int D.39555;
  unsigned int D.39569;
  int D.39570;
  int D.39573;
  struct MonoInst * * sp.302;
  struct MonoDebugOptions * D.39584;
  int D.39585;
  struct MonoDebugOptions * D.39593;
  int D.39594;
  struct MonoLoaderError * D.39599;
  struct MonoDebugOptions * D.39600;
  int D.39601;
  int D.39607;
  gchar * D.39610;
  <unnamed type> D.39611;
  int D.39614;
  <unnamed type> D.39625;
  unsigned char * D.39630;
  int D.39633;
  unsigned char * D.39638;
  unsigned int D.39639;
  unsigned int D.39640;
  unsigned int D.39641;
  unsigned int D.39642;
  unsigned int D.39643;
  unsigned int D.39644;
  unsigned int D.39645;
  unsigned int D.39646;
  unsigned int D.39647;
  unsigned int D.39648;
  struct MonoClass * D.39651;
  struct MonoClass * D.39652;
  struct MonoMethodSignature * D.39658;
  struct MonoDebugOptions * D.39659;
  int D.39660;
  <unnamed type> D.39662;
  int D.39665;
  struct MonoMethodSignature * D.39668;
  short unsigned int D.39669;
  struct MonoMethodSignature * D.39670;
  short unsigned int D.39671;
  long int D.39674;
  struct MonoInst * D.39675;
  int D.39676;
  int D.39677;
  int D.39678;
  long int D.39682;
  struct MonoInst * D.39683;
  int D.39684;
  int D.39685;
  char * D.39693;
  struct MonoInst * D.39694;
  struct MonoInst * argconst.303;
  struct MonoInst * * sp.304;
  int num_calls.305;
  int D.39699;
  struct MonoDebugOptions * D.39706;
  int D.39707;
  struct MonoDebugOptions * D.39715;
  int D.39716;
  struct MonoLoaderError * D.39721;
  struct MonoDebugOptions * D.39722;
  int D.39723;
  <unnamed type> D.39725;
  int D.39728;
  <unnamed type> D.39739;
  struct MonoInst * D.39742;
  struct MonoInst * * sp.306;
  struct MonoInst * D.39746;
  struct MonoInst * * sp.307;
  struct MonoInst * D.39749;
  int num_calls.308;
  int D.39751;
  struct MonoDebugOptions * D.39758;
  int D.39759;
  unsigned char * D.39761;
  struct MonoDebugOptions * D.39768;
  int D.39769;
  short unsigned int D.39771;
  short unsigned int D.39772;
  int D.39773;
  int D.39774;
  int D.39775;
  int D.39776;
  struct MonoDebugOptions * D.39783;
  int D.39784;
  unsigned int D.39786;
  short unsigned int D.39787;
  unsigned int D.39788;
  int D.39789;
  struct MonoClass * D.39792;
  struct MonoInst * * sp.309;
  struct MonoDebugOptions * D.39803;
  int D.39804;
  struct MonoDebugOptions * D.39812;
  int D.39813;
  struct MonoDebugOptions * D.39821;
  int D.39822;
  unsigned int D.39824;
  int D.39825;
  int D.39828;
  struct MonoInst * iftmp.310;
  struct MonoInst * iftmp.311;
  _Bool D.39841;
  long int D.39842;
  long int D.39843;
  _Bool D.39846;
  long int D.39847;
  long int D.39848;
  unsigned char D.39851;
  unsigned char D.39852;
  unsigned char D.39853;
  unsigned char D.39854;
  struct MonoInst * * sp.312;
  struct MonoDebugOptions * D.39865;
  int D.39866;
  struct MonoDebugOptions * D.39874;
  int D.39875;
  struct MonoDebugOptions * D.39883;
  int D.39884;
  struct MonoType * * D.39888;
  struct MonoType * D.39889;
  int D.39890;
  struct MonoDebugOptions * D.39897;
  int D.39898;
  unsigned int D.39900;
  short unsigned int D.39901;
  struct MonoClass * D.39904;
  struct MonoDebugOptions * D.39914;
  int D.39915;
  struct MonoDebugOptions * D.39923;
  int D.39924;
  struct MonoDebugOptions * D.39932;
  int D.39933;
  unsigned int D.39935;
  short unsigned int D.39936;
  unsigned int D.39937;
  int D.39938;
  struct MonoClass * D.39941;
  struct MonoInst * * sp.313;
  struct MonoDebugOptions * D.39952;
  int D.39953;
  struct MonoDebugOptions * D.39961;
  int D.39962;
  struct MonoDebugOptions * D.39970;
  int D.39971;
  unsigned char D.39975;
  unsigned char D.39976;
  unsigned int D.39977;
  int D.39978;
  struct MonoType * D.39981;
  int D.39982;
  struct MonoInst * iftmp.314;
  int D.39988;
  unsigned int D.39989;
  sizetype D.39992;
  sizetype D.39993;
  sizetype D.39994;
  struct MonoInst * * D.39995;
  struct MonoInst * iftmp.315;
  int D.39998;
  unsigned int D.39999;
  sizetype D.40002;
  sizetype D.40003;
  struct MonoInst * * D.40004;
  _Bool D.40006;
  long int D.40007;
  long int D.40008;
  _Bool D.40011;
  long int D.40012;
  long int D.40013;
  unsigned char D.40016;
  unsigned char D.40017;
  unsigned char D.40018;
  unsigned char D.40019;
  struct MonoInst * * sp.316;
  struct MonoDebugOptions * D.40030;
  int D.40031;
  struct MonoDebugOptions * D.40039;
  int D.40040;
  struct MonoDebugOptions * D.40048;
  int D.40049;
  int D.40053;
  struct MonoDebugOptions * D.40060;
  int D.40061;
  struct MonoDebugOptions * D.40069;
  int D.40070;
  struct MonoDebugOptions * D.40078;
  int D.40079;
  unsigned int D.40082;
  int D.40083;
  unsigned char D.40089;
  struct MonoInst * * sp.317;
  struct MonoDebugOptions * D.40097;
  int D.40098;
  struct MonoDebugOptions * D.40107;
  int D.40108;
  long unsigned int D.40113;
  long unsigned int D.40114;
  unsigned int D.40117;
  unsigned int D.40118;
  unsigned int D.40121;
  long int D.40122;
  unsigned int D.40125;
  long int D.40126;
  unsigned int D.40130;
  _Bool D.40131;
  long int D.40132;
  long int D.40133;
  unsigned int D.40136;
  long int D.40137;
  struct MonoDebugOptions * D.40144;
  int D.40145;
  unsigned char * D.40147;
  struct MonoDebugOptions * D.40154;
  int D.40155;
  unsigned int D.40157;
  struct MonoDebugOptions * D.40164;
  int D.40165;
  struct MonoDebugOptions * D.40173;
  int D.40174;
  struct MonoClass * klass.318;
  struct MonoDebugOptions * D.40180;
  int D.40181;
  int D.40183;
  long int D.40186;
  struct MonoInst * D.40187;
  int D.40188;
  int D.40189;
  struct MonoDebugOptions * D.40200;
  int D.40201;
  struct MonoDebugOptions * D.40206;
  int D.40207;
  struct MonoDebugOptions * D.40215;
  int D.40216;
  struct MonoInst * * D.40222;
  struct MonoInst * D.40223;
  short unsigned int D.40224;
  long int D.40226;
  int D.40228;
  int D.40237;
  struct MonoInst * D.40238;
  struct MonoDebugOptions * D.40248;
  int D.40249;
  unsigned char D.40251;
  int D.40252;
  int D.40253;
  int D.40256;
  unsigned int D.40259;
  long int D.40260;
  unsigned int D.40263;
  unsigned int D.40264;
  long int D.40265;
  unsigned int D.40268;
  unsigned int D.40269;
  unsigned int D.40272;
  unsigned int D.40273;
  _Bool D.40274;
  long int D.40275;
  long int D.40276;
  long int D.40279;
  struct MonoInst * D.40280;
  int D.40281;
  int D.40282;
  struct MonoInst * D.40283;
  long int D.40284;
  long unsigned int D.40285;
  long unsigned int D.40286;
  struct MonoInst * * D.40287;
  struct MonoInst * D.40288;
  struct MonoType * D.40289;
  unsigned int D.40290;
  short unsigned int D.40291;
  struct MonoInst * D.40292;
  long int D.40293;
  long unsigned int D.40294;
  long unsigned int D.40295;
  struct MonoInst * * D.40296;
  struct MonoInst * D.40297;
  struct MonoType * D.40298;
  struct MonoInst * D.40299;
  long int D.40300;
  long unsigned int D.40301;
  long unsigned int D.40302;
  struct MonoInst * * D.40303;
  struct MonoInst * D.40304;
  struct MonoClass * D.40305;
  struct MonoInst * D.40306;
  long int D.40307;
  long unsigned int D.40308;
  long unsigned int D.40309;
  struct MonoInst * * D.40310;
  struct MonoInst * D.40311;
  int D.40312;
  unsigned char D.40313;
  <unnamed type> D.40314;
  unsigned int D.40315;
  int D.40316;
  short unsigned int D.40317;
  struct MonoInst * D.40320;
  long int D.40321;
  long unsigned int D.40322;
  long unsigned int D.40323;
  struct MonoInst * * D.40324;
  struct MonoInst * D.40325;
  struct MonoType * D.40326;
  struct MonoClass * D.40327;
  int D.40331;
  const char * D.40340;
  gchar * D.40341;
  struct MonoDebugOptions * D.40350;
  int D.40351;
  struct MonoDebugOptions * D.40359;
  int D.40360;
  unsigned int D.40364;
  long unsigned int D.40366;
  long unsigned int D.40367;
  int D.40370;
  unsigned char D.40374;
  struct MonoDebugOptions * D.40375;
  int D.40376;
  struct MonoType * D.40378;
  int D.40379;
  long int D.40380;
  unsigned int D.40381;
  int D.40382;
  struct MonoInst * * sp.319;
  const char * D.40389;
  gchar * D.40390;
  struct MonoDebugOptions * D.40399;
  int D.40400;
  struct MonoInst * iftmp.320;
  long int D.40408;
  struct MonoInst * D.40409;
  int D.40410;
  int D.40411;
  unsigned char D.40412;
  unsigned char D.40413;
  struct MonoClass * D.40414;
  unsigned int D.40415;
  int D.40416;
  struct MonoType * D.40419;
  int D.40420;
  struct MonoInst * iftmp.321;
  int D.40426;
  int D.40427;
  unsigned int D.40428;
  sizetype D.40431;
  sizetype D.40432;
  sizetype D.40433;
  struct MonoInst * * D.40434;
  struct MonoInst * iftmp.322;
  int D.40437;
  unsigned int D.40438;
  sizetype D.40441;
  sizetype D.40442;
  struct MonoInst * * D.40443;
  _Bool D.40445;
  long int D.40446;
  long int D.40447;
  _Bool D.40450;
  long int D.40451;
  long int D.40452;
  unsigned char D.40455;
  unsigned char D.40456;
  unsigned char D.40457;
  unsigned char D.40458;
  struct MonoType * D.40462;
  unsigned int D.40463;
  short unsigned int D.40464;
  int D.40465;
  unsigned int D.40466;
  int D.40467;
  struct MonoInst * * sp.323;
  struct MonoDebugOptions * D.40476;
  int D.40477;
  struct MonoDebugOptions * D.40483;
  int D.40484;
  struct MonoDebugOptions * D.40490;
  int D.40491;
  struct MonoDebugOptions * D.40497;
  int D.40498;
  struct MonoDebugOptions * D.40506;
  int D.40507;
  struct MonoBasicBlock * D.40509;
  struct MonoBasicBlock * D.40512;
  struct MonoInst * D.40516;
  long int D.40525;
  struct MonoInst * D.40526;
  int D.40527;
  int D.40528;
  long int D.40529;
  long unsigned int D.40530;
  long unsigned int D.40531;
  struct MonoInst * * D.40532;
  struct MonoInst * D.40533;
  struct MonoType * D.40534;
  unsigned int D.40535;
  short unsigned int D.40536;
  struct MonoClass * D.40537;
  int D.40538;
  int D.40539;
  short unsigned int D.40540;
  struct MonoClass * D.40543;
  struct MonoInst * D.40549;
  struct MonoType * D.40554;
  long unsigned int D.40555;
  struct MonoInst * * D.40560;
  long unsigned int D.40561;
  long unsigned int D.40562;
  long int D.40565;
  struct MonoInst * D.40566;
  int D.40567;
  int D.40568;
  int D.40569;
  unsigned int D.40573;
  struct MonoInst * D.40580;
  short int D.40583;
  short unsigned int D.40586;
  unsigned char D.40589;
  unsigned char D.40590;
  struct MonoInst * D.40593;
  struct MonoBasicBlock * D.40597;
  struct MonoInst * D.40598;
  long unsigned int D.40604;
  long unsigned int D.40605;
  unsigned int i.324;
  unsigned int D.40607;
  long unsigned int D.40608;
  long unsigned int D.40609;
  long unsigned int D.40612;
  long unsigned int D.40613;
  long unsigned int D.40614;
  long int D.40617;
  struct MonoInst * D.40618;
  int D.40619;
  int D.40620;
  long int D.40621;
  unsigned int i.325;
  unsigned int D.40625;
  int D.40626;
  int D.40627;
  unsigned int D.40628;
  struct GHashTable * D.40629;
  unsigned int D.40632;
  int D.40633;
  int D.40636;
  gchar * D.40639;
  struct GSList * D.40640;
  struct GSList * D.40641;
  int D.40642;
  struct GSList * D.40647;
  _Bool D.40648;
  long int D.40649;
  long int D.40650;
  struct GSList * D.40653;
  struct MonoError error;
  struct MonoInst * ins;
  struct MonoInst * * sp;
  struct MonoInst * * stack_start;
  struct MonoBasicBlock * bblock;
  struct MonoBasicBlock * tblock;
  struct MonoBasicBlock * init_localsbb;
  struct MonoSimpleBasicBlock * bb;
  struct MonoSimpleBasicBlock * original_bb;
  struct MonoMethod * cmethod;
  struct MonoMethod * method_definition;
  struct MonoInst * * arg_array;
  struct MonoMethodHeader * header;
  struct MonoImage * image;
  guint32 token;
  guint32 ins_flag;
  struct MonoClass * klass;
  struct MonoClass * constrained_call;
  unsigned char * ip;
  unsigned char * end;
  unsigned char * target;
  unsigned char * err_pos;
  struct MonoMethodSignature * sig;
  struct MonoGenericContext * generic_context;
  struct MonoGenericContainer * generic_container;
  struct MonoType * * param_types;
  int i;
  int n;
  int start_new_bblock;
  int dreg;
  int num_calls;
  int inline_costs;
  int breakpoint_id;
  guint num_args;
  MonoBoolean security;
  MonoBoolean pinvoke;
  struct MonoSecurityManager * secman;
  struct MonoDeclSecurityActions actions;
  struct GSList * class_inits;
  gboolean dont_verify;
  gboolean dont_verify_stloc;
  gboolean readonly;
  int context_used;
  gboolean init_locals;
  gboolean seq_points;
  gboolean skip_dead_blocks;
  gboolean disable_inline;
  gboolean sym_seq_points;
  struct MonoInst * cached_tls_addr;
  struct MonoDebugMethodInfo * minfo;
  struct MonoBitSet * seq_point_locs;
  struct MonoBitSet * seq_point_set_locs;
  void exception_exit = <<< error >>>;
  void unverified = <<< error >>>;
  void inline_failure = <<< error >>>;
  void load_error = <<< error >>>;
  void call_end = <<< error >>>;
  void cleanup = <<< error >>>;

  try
    {
      tblock = 0B;
      init_localsbb = 0B;
      bb = 0B;
      original_bb = 0B;
      constrained_call = 0B;
      generic_context = 0B;
      generic_container = 0B;
      num_calls = 0;
      inline_costs = 0;
      breakpoint_id = 0;
      secman = 0B;
      class_inits = 0B;
      readonly = 0;
      sym_seq_points = 0;
      cached_tls_addr = 0B;
      seq_point_locs = 0B;
      seq_point_set_locs = 0B;
      disable_inline = is_jit_optimizer_disabled (method);
      D.30178 = method->klass;
      D.30179 = D.30178->image;
      D.30180 = D.30179->assembly;
      D.30181 = D.30180->corlib_internal;
      D.30182 = D.30181 != 0;
      dont_verify = (gboolean) D.30182;
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30184 = D.30183 & 4467570830351532032;
      D.30185 = D.30184 == 1441151880758558720;
      D.30186 = (int) D.30185;
      dont_verify = D.30186 | dont_verify;
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30184 = D.30183 & 4467570830351532032;
      D.30187 = D.30184 == 1585267068834414592;
      D.30188 = (int) D.30187;
      dont_verify = D.30188 | dont_verify;
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30184 = D.30183 & 4467570830351532032;
      D.30189 = D.30184 == 864691128455135232;
      D.30190 = (int) D.30189;
      dont_verify = D.30190 | dont_verify;
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30184 = D.30183 & 4467570830351532032;
      D.30191 = D.30184 == 3891110078048108544;
      D.30192 = (int) D.30191;
      dont_verify = D.30192 | dont_verify;
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30184 = D.30183 & 4467570830351532032;
      D.30193 = D.30184 == 3746994889972252672;
      D.30194 = (int) D.30193;
      dont_verify = D.30194 | dont_verify;
      D.30195 = mono_security_get_mode ();
      D.30196 = D.30195 == 3;
      D.30197 = (int) D.30196;
      dont_verify = D.30197 | dont_verify;
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30184 = D.30183 & 4467570830351532032;
      D.30189 = D.30184 == 864691128455135232;
      dont_verify_stloc = (gboolean) D.30189;
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30184 = D.30183 & 4467570830351532032;
      D.30198 = D.30184 == 3602879701896396800;
      D.30199 = (int) D.30198;
      dont_verify_stloc = D.30199 | dont_verify_stloc;
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30184 = D.30183 & 4467570830351532032;
      D.30200 = D.30184 == 720575940379279360;
      D.30201 = (int) D.30200;
      dont_verify_stloc = D.30201 | dont_verify_stloc;
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30184 = D.30183 & 4467570830351532032;
      D.30202 = D.30184 == 3026418949592973312;
      D.30203 = (int) D.30202;
      dont_verify_stloc = D.30203 | dont_verify_stloc;
      D.30178 = method->klass;
      image = D.30178->image;
      header = mono_method_get_header (method);
      if (header == 0B) goto <D.30204>; else goto <D.30205>;
      <D.30204>:
      {
        struct MonoLoaderError * error;

        error = mono_loader_get_last_error ();
        if (error != 0B) goto <D.30206>; else goto <D.30207>;
        <D.30206>:
        D.30208 = error->exception_type;
        D.30209 = (int) D.30208;
        mono_cfg_set_exception (cfg, D.30209);
        goto <D.30210>;
        <D.30207>:
        mono_cfg_set_exception (cfg, 3);
        D.30211 = cfg->method;
        D.30212 = D.30211->name;
        D.30213 = monoeg_g_strdup_printf ("Missing or incorrect header for method %s", D.30212);
        cfg->exception_message = D.30213;
        <D.30210>:
        goto exception_exit;
      }
      <D.30205>:
      generic_container = mono_method_get_generic_container (method);
      sig = mono_method_signature (method);
      D.30214 = sig->hasthis;
      D.30215 = (int) D.30214;
      D.30216 = sig->param_count;
      D.30217 = (int) D.30216;
      D.30218 = D.30215 + D.30217;
      num_args = (guint) D.30218;
      ip = header->code;
      cfg->cil_start = ip;
      D.30219 = header->code_size;
      D.30220 = (sizetype) D.30219;
      end = ip + D.30220;
      D.30221 = cfg->stat_cil_code_size;
      D.30222 = (unsigned int) D.30221;
      D.30219 = header->code_size;
      D.30223 = D.30222 + D.30219;
      D.30224 = (int) D.30223;
      cfg->stat_cil_code_size = D.30224;
      D.30225 = header->init_locals;
      init_locals = (gboolean) D.30225;
      D.30229 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.30230 = D.30229 & 288230376151711744;
      if (D.30230 != 0) goto <D.30231>; else goto <D.30227>;
      <D.30231>:
      D.30211 = cfg->method;
      if (D.30211 == method) goto <D.30232>; else goto <D.30227>;
      <D.30232>:
      iftmp.58 = 1;
      goto <D.30228>;
      <D.30227>:
      iftmp.58 = 0;
      <D.30228>:
      seq_points = iftmp.58;
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30184 = D.30183 & 4467570830351532032;
      if (D.30184 == 720575940379279360) goto <D.30233>; else goto <D.30234>;
      <D.30233>:
      seq_points = 0;
      <D.30234>:
      D.30229 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.30230 = D.30229 & 288230376151711744;
      if (D.30230 != 0) goto <D.30235>; else goto <D.30236>;
      <D.30235>:
      D.30211 = cfg->method;
      if (D.30211 == method) goto <D.30237>; else goto <D.30238>;
      <D.30237>:
      minfo = mono_debug_lookup_method (method);
      if (minfo != 0B) goto <D.30239>; else goto <D.30240>;
      <D.30239>:
      {
        int i;
        int n_il_offsets;
        int * il_offsets;
        int * line_numbers;

        try
          {
            mono_debug_symfile_get_line_numbers_full (minfo, 0B, 0B, &n_il_offsets, &il_offsets, &line_numbers, 0B, 0B);
            D.30241 = cfg->mempool;
            D.30219 = header->code_size;
            D.30242 = mono_bitset_alloc_size (D.30219, 0);
            D.30243 = mono_mempool_alloc0 (D.30241, D.30242);
            D.30219 = header->code_size;
            seq_point_locs = mono_bitset_mem_new (D.30243, D.30219, 0);
            D.30241 = cfg->mempool;
            D.30219 = header->code_size;
            D.30244 = mono_bitset_alloc_size (D.30219, 0);
            D.30245 = mono_mempool_alloc0 (D.30241, D.30244);
            D.30219 = header->code_size;
            seq_point_set_locs = mono_bitset_mem_new (D.30245, D.30219, 0);
            sym_seq_points = 1;
            i = 0;
            goto <D.27343>;
            <D.27342>:
            il_offsets.59 = il_offsets;
            D.30247 = (long unsigned int) i;
            D.30248 = D.30247 * 4;
            D.30249 = il_offsets.59 + D.30248;
            D.30250 = *D.30249;
            D.30251 = (unsigned int) D.30250;
            D.30219 = header->code_size;
            if (D.30251 < D.30219) goto <D.30252>; else goto <D.30253>;
            <D.30252>:
            il_offsets.59 = il_offsets;
            D.30247 = (long unsigned int) i;
            D.30248 = D.30247 * 4;
            D.30249 = il_offsets.59 + D.30248;
            D.30250 = *D.30249;
            D.30254 = (long unsigned int) D.30250;
            D.30255 = D.30254 / 64;
            D.30256 = seq_point_locs->data[D.30255];
            il_offsets.59 = il_offsets;
            D.30247 = (long unsigned int) i;
            D.30248 = D.30247 * 4;
            D.30249 = il_offsets.59 + D.30248;
            D.30250 = *D.30249;
            D.30257 = (unsigned int) D.30250;
            D.30258 = D.30257 & 63;
            D.30259 = 1 << D.30258;
            D.30260 = D.30256 | D.30259;
            seq_point_locs->data[D.30255] = D.30260;
            <D.30253>:
            i = i + 1;
            <D.27343>:
            n_il_offsets.60 = n_il_offsets;
            if (i < n_il_offsets.60) goto <D.27342>; else goto <D.27344>;
            <D.27344>:
            il_offsets.59 = il_offsets;
            monoeg_g_free (il_offsets.59);
            line_numbers.61 = line_numbers;
            monoeg_g_free (line_numbers.61);
          }
        finally
          {
            n_il_offsets = {CLOBBER};
            il_offsets = {CLOBBER};
            line_numbers = {CLOBBER};
          }
      }
      <D.30240>:
      <D.30238>:
      <D.30236>:
      init_locals = 1;
      method_definition = method;
      goto <D.27347>;
      <D.27346>:
      {
        struct MonoMethodInflated * imethod;

        imethod = method_definition;
        method_definition = imethod->declaring;
      }
      <D.27347>:
      D.30263 = BIT_FIELD_REF <*method_definition, 64, 256>;
      D.30264 = D.30263 & 2251799813685248;
      if (D.30264 != 0) goto <D.27346>; else goto <D.27348>;
      <D.27348>:
      if (dont_verify == 0) goto <D.30265>; else goto <D.30266>;
      <D.30265>:
      D.30267 = cfg->domain;
      D.30268 = mini_assembly_can_skip_verification (D.30267, method);
      if (D.30268 != 0) goto <D.30269>; else goto <D.30270>;
      <D.30269>:
      dont_verify = 1;
      dont_verify_stloc = 1;
      <D.30270>:
      <D.30266>:
      D.30271 = BIT_FIELD_REF <*sig, 64, 64>;
      D.30272 = D.30271 & 64;
      if (D.30272 != 0) goto <D.30273>; else goto <D.30274>;
      <D.30273>:
      generic_context = mono_method_get_context (method);
      goto <D.30275>;
      <D.30274>:
      if (generic_container != 0B) goto <D.30276>; else goto <D.30277>;
      <D.30276>:
      generic_context = &generic_container->context;
      <D.30277>:
      <D.30275>:
      cfg->generic_context = generic_context;
      D.30278 = cfg->generic_sharing_context;
      if (D.30278 == 0B) goto <D.30279>; else goto <D.30280>;
      <D.30279>:
      D.30271 = BIT_FIELD_REF <*sig, 64, 64>;
      D.30281 = D.30271 & 32;
      D.30282 = D.30281 != 0;
      D.30283 = (long int) D.30282;
      D.30284 = __builtin_expect (D.30283, 0);
      if (D.30284 != 0) goto <D.30285>; else goto <D.30286>;
      <D.30285>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6727, "!sig->has_type_parameters");
      <D.30286>:
      <D.30280>:
      D.30287 = sig->generic_param_count;
      if (D.30287 != 0) goto <D.30288>; else goto <D.30289>;
      <D.30288>:
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30184 = D.30183 & 4467570830351532032;
      if (D.30184 == 0) goto <D.30290>; else goto <D.30291>;
      <D.30290>:
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30292 = D.30183 & 2251799813685248;
      D.30293 = D.30292 == 0;
      D.30294 = (long int) D.30293;
      D.30295 = __builtin_expect (D.30294, 0);
      if (D.30295 != 0) goto <D.30296>; else goto <D.30297>;
      <D.30296>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6730, "method->is_inflated");
      <D.30297>:
      D.30298 = mono_method_get_context (method);
      D.30299 = D.30298->method_inst;
      D.30300 = D.30299 == 0B;
      D.30301 = (long int) D.30300;
      D.30302 = __builtin_expect (D.30301, 0);
      if (D.30302 != 0) goto <D.30303>; else goto <D.30304>;
      <D.30303>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6731, "mono_method_get_context (method)->method_inst");
      <D.30304>:
      <D.30291>:
      <D.30289>:
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30292 = D.30183 & 2251799813685248;
      if (D.30292 != 0) goto <D.30305>; else goto <D.30306>;
      <D.30305>:
      D.30307 = mono_method_get_context (method);
      D.30308 = D.30307->method_inst;
      if (D.30308 != 0B) goto <D.30309>; else goto <D.30310>;
      <D.30309>:
      D.30287 = sig->generic_param_count;
      D.30311 = D.30287 == 0;
      D.30312 = (long int) D.30311;
      D.30313 = __builtin_expect (D.30312, 0);
      if (D.30313 != 0) goto <D.30314>; else goto <D.30315>;
      <D.30314>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6734, "sig->generic_param_count");
      <D.30315>:
      <D.30310>:
      <D.30306>:
      D.30211 = cfg->method;
      if (D.30211 == method) goto <D.30316>; else goto <D.30317>;
      <D.30316>:
      cfg->real_offset = 0;
      goto <D.30318>;
      <D.30317>:
      cfg->real_offset = inline_offset;
      <D.30318>:
      D.30241 = cfg->mempool;
      D.30219 = header->code_size;
      D.30319 = D.30219 * 8;
      D.30320 = mono_mempool_alloc0 (D.30241, D.30319);
      cfg->cil_offset_to_bb = D.30320;
      D.30219 = header->code_size;
      D.30321 = (int) D.30219;
      cfg->cil_offset_to_bb_len = D.30321;
      cfg->current_method = method;
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.30323>; else goto <D.30324>;
      <D.30323>:
      D.30325 = mono_method_full_name (method, 1);
      printf ("method to IR %s\n", D.30325);
      <D.30324>:
      D.30241 = cfg->mempool;
      D.30326 = num_args * 8;
      param_types = mono_mempool_alloc (D.30241, D.30326);
      D.30271 = BIT_FIELD_REF <*sig, 64, 64>;
      D.30327 = D.30271 & 512;
      if (D.30327 != 0) goto <D.30328>; else goto <D.30329>;
      <D.30328>:
      D.30178 = method->klass;
      D.30331 = BIT_FIELD_REF <*D.30178, 64, 256>;
      D.30332 = D.30331 & 1152921504606846976;
      if (D.30332 != 0) goto <D.30333>; else goto <D.30334>;
      <D.30333>:
      D.30178 = method->klass;
      iftmp.62 = &D.30178->this_arg;
      goto <D.30335>;
      <D.30334>:
      D.30178 = method->klass;
      iftmp.62 = &D.30178->byval_arg;
      <D.30335>:
      *param_types = iftmp.62;
      <D.30329>:
      n = 0;
      goto <D.27350>;
      <D.27349>:
      D.30214 = sig->hasthis;
      D.30215 = (int) D.30214;
      D.30336 = D.30215 + n;
      D.30337 = (long unsigned int) D.30336;
      D.30338 = D.30337 * 8;
      D.30339 = param_types + D.30338;
      D.30340 = sig->params[n];
      *D.30339 = D.30340;
      n = n + 1;
      <D.27350>:
      D.30216 = sig->param_count;
      D.30217 = (int) D.30216;
      if (D.30217 > n) goto <D.27349>; else goto <D.27351>;
      <D.27351>:
      cfg->arg_types = param_types;
      dont_inline = monoeg_g_list_prepend (dont_inline, method);
      D.30211 = cfg->method;
      if (D.30211 == method) goto <D.30341>; else goto <D.30342>;
      <D.30341>:
      D.30343 = cfg->prof_options;
      D.30344 = D.30343 & 16384;
      if (D.30344 != 0) goto <D.30345>; else goto <D.30346>;
      <D.30345>:
      D.30211 = cfg->method;
      D.30219 = header->code_size;
      D.30347 = (int) D.30219;
      D.30348 = mono_profiler_coverage_alloc (D.30211, D.30347);
      cfg->coverage_info = D.30348;
      <D.30346>:
      D.30241 = cfg->mempool;
      start_bblock = mono_mempool_alloc0 (D.30241, 296);
      D.30349 = cfg->num_bblocks;
      D.30350 = D.30349;
      D.30351 = D.30350 + 1;
      cfg->num_bblocks = D.30351;
      D.30352 = (int) D.30350;
      start_bblock->block_num = D.30352;
      cfg->bb_entry = start_bblock;
      start_bblock->cil_code = 0B;
      start_bblock->cil_length = 0;
      D.30241 = cfg->mempool;
      end_bblock = mono_mempool_alloc0 (D.30241, 296);
      D.30349 = cfg->num_bblocks;
      D.30353 = D.30349;
      D.30354 = D.30353 + 1;
      cfg->num_bblocks = D.30354;
      D.30355 = (int) D.30353;
      end_bblock->block_num = D.30355;
      cfg->bb_exit = end_bblock;
      end_bblock->cil_code = 0B;
      end_bblock->cil_length = 0;
      D.30356 = end_bblock->flags;
      D.30357 = D.30356 | 32;
      end_bblock->flags = D.30357;
      D.30349 = cfg->num_bblocks;
      D.30358 = D.30349 != 2;
      D.30359 = (long int) D.30358;
      D.30360 = __builtin_expect (D.30359, 0);
      if (D.30360 != 0) goto <D.30361>; else goto <D.30362>;
      <D.30361>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6780, "cfg->num_bblocks == 2");
      <D.30362>:
      arg_array = cfg->args;
      D.30363 = BIT_FIELD_REF <*header, 64, 64>;
      D.30364 = D.30363 & 65534;
      if (D.30364 != 0) goto <D.30365>; else goto <D.30366>;
      <D.30365>:
      D.30367 = monoeg_g_hash_table_new (0B, 0B);
      cfg->spvars = D.30367;
      D.30368 = monoeg_g_hash_table_new (0B, 0B);
      cfg->exvars = D.30368;
      <D.30366>:
      i = 0;
      goto <D.27358>;
      <D.27357>:
      {
        struct MonoBasicBlock * try_bb;
        struct MonoExceptionClause * clause;

        D.30369 = header->clauses;
        D.30370 = (long unsigned int) i;
        D.30371 = D.30370 * 32;
        clause = D.30369 + D.30371;
        D.30372 = cfg->cil_offset_to_bb;
        D.30373 = clause->try_offset;
        D.30374 = (sizetype) D.30373;
        D.30375 = ip + D.30374;
        D.30376 = (long int) D.30375;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.30379 = D.30376 - D.30378;
        D.30380 = (long unsigned int) D.30379;
        D.30381 = D.30380 * 8;
        D.30382 = D.30372 + D.30381;
        try_bb = *D.30382;
        if (try_bb == 0B) goto <D.30383>; else goto <D.30384>;
        <D.30383>:
        D.30373 = clause->try_offset;
        D.30374 = (sizetype) D.30373;
        D.30375 = ip + D.30374;
        if (D.30375 >= end) goto <D.30385>; else goto <D.30387>;
        <D.30387>:
        D.30373 = clause->try_offset;
        D.30374 = (sizetype) D.30373;
        D.30375 = ip + D.30374;
        D.30388 = header->code;
        if (D.30375 < D.30388) goto <D.30385>; else goto <D.30386>;
        <D.30385>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.30390>; else goto <D.30391>;
        <D.30390>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.30392>; else goto <D.30393>;
        <D.30392>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.30393>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.30391>:
        D.30394 = mini_get_debug_options ();
        D.30395 = D.30394->break_on_unverified;
        if (D.30395 != 0) goto <D.30396>; else goto unverified;
        <D.30396>:
        raise (5);
        <D.30386>:
        D.30241 = cfg->mempool;
        try_bb = mono_mempool_alloc0 (D.30241, 296);
        D.30349 = cfg->num_bblocks;
        D.30397 = D.30349;
        D.30398 = D.30397 + 1;
        cfg->num_bblocks = D.30398;
        D.30399 = (int) D.30397;
        try_bb->block_num = D.30399;
        D.30373 = clause->try_offset;
        D.30374 = (sizetype) D.30373;
        D.30375 = ip + D.30374;
        try_bb->cil_code = D.30375;
        D.30400 = try_bb->cil_code;
        if (D.30400 != 0B) goto <D.30401>; else goto <D.30402>;
        <D.30401>:
        D.30372 = cfg->cil_offset_to_bb;
        D.30400 = try_bb->cil_code;
        D.30403 = (long int) D.30400;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.30404 = D.30403 - D.30378;
        D.30405 = (long unsigned int) D.30404;
        D.30406 = D.30405 * 8;
        D.30407 = D.30372 + D.30406;
        *D.30407 = try_bb;
        <D.30402>:
        D.30408 = cfg->real_offset;
        try_bb->real_offset = D.30408;
        <D.30384>:
        D.30373 = clause->try_offset;
        try_bb->real_offset = D.30373;
        try_bb->try_start = 1;
        D.30409 = i + 1;
        D.30410 = D.30409 << 8;
        D.30411 = (unsigned int) D.30410;
        D.30412 = clause->flags;
        D.30413 = D.30411 | D.30412;
        try_bb->region = D.30413;
        D.30372 = cfg->cil_offset_to_bb;
        D.30414 = clause->handler_offset;
        D.30415 = (sizetype) D.30414;
        D.30416 = ip + D.30415;
        D.30417 = (long int) D.30416;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.30418 = D.30417 - D.30378;
        D.30419 = (long unsigned int) D.30418;
        D.30420 = D.30419 * 8;
        D.30421 = D.30372 + D.30420;
        tblock = *D.30421;
        if (tblock == 0B) goto <D.30422>; else goto <D.30423>;
        <D.30422>:
        D.30414 = clause->handler_offset;
        D.30415 = (sizetype) D.30414;
        D.30416 = ip + D.30415;
        if (D.30416 >= end) goto <D.30424>; else goto <D.30426>;
        <D.30426>:
        D.30414 = clause->handler_offset;
        D.30415 = (sizetype) D.30414;
        D.30416 = ip + D.30415;
        D.30388 = header->code;
        if (D.30416 < D.30388) goto <D.30424>; else goto <D.30425>;
        <D.30424>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.30427>; else goto <D.30428>;
        <D.30427>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.30429>; else goto <D.30430>;
        <D.30429>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.30430>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.30428>:
        D.30431 = mini_get_debug_options ();
        D.30432 = D.30431->break_on_unverified;
        if (D.30432 != 0) goto <D.30433>; else goto unverified;
        <D.30433>:
        raise (5);
        <D.30425>:
        D.30241 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30241, 296);
        D.30349 = cfg->num_bblocks;
        D.30434 = D.30349;
        D.30435 = D.30434 + 1;
        cfg->num_bblocks = D.30435;
        D.30436 = (int) D.30434;
        tblock->block_num = D.30436;
        D.30414 = clause->handler_offset;
        D.30415 = (sizetype) D.30414;
        D.30416 = ip + D.30415;
        tblock->cil_code = D.30416;
        D.30437 = tblock->cil_code;
        if (D.30437 != 0B) goto <D.30438>; else goto <D.30439>;
        <D.30438>:
        D.30372 = cfg->cil_offset_to_bb;
        D.30437 = tblock->cil_code;
        D.30440 = (long int) D.30437;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.30441 = D.30440 - D.30378;
        D.30442 = (long unsigned int) D.30441;
        D.30443 = D.30442 * 8;
        D.30444 = D.30372 + D.30443;
        *D.30444 = tblock;
        <D.30439>:
        D.30408 = cfg->real_offset;
        tblock->real_offset = D.30408;
        <D.30423>:
        D.30414 = clause->handler_offset;
        tblock->real_offset = D.30414;
        D.30445 = tblock->flags;
        D.30446 = D.30445 | 16;
        tblock->flags = D.30446;
        if (0 != 0) goto <D.30447>; else goto <D.30448>;
        <D.30447>:
        link_bblock (cfg, try_bb, tblock);
        <D.30448>:
        D.30414 = clause->handler_offset;
        D.30415 = (sizetype) D.30414;
        D.30416 = ip + D.30415;
        D.30449 = *D.30416;
        if (D.30449 == 38) goto <D.30450>; else goto <D.30451>;
        <D.30450>:
        D.30445 = tblock->flags;
        D.30452 = D.30445 | 4;
        tblock->flags = D.30452;
        <D.30451>:
        D.30412 = clause->flags;
        D.30455 = D.30412 + 4294967295;
        if (D.30455 <= 1) goto <D.30453>; else goto <D.30456>;
        <D.30456>:
        D.30412 = clause->flags;
        if (D.30412 == 4) goto <D.30453>; else goto <D.30454>;
        <D.30453>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 736;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        D.30462 = tblock->last_ins;
        if (D.30462 != 0B) goto <D.30463>; else goto <D.30464>;
        <D.30463>:
        D.30462 = tblock->last_ins;
        D.30462->next = ins;
        D.30462 = tblock->last_ins;
        ins->prev = D.30462;
        tblock->last_ins = ins;
        goto <D.30465>;
        <D.30464>:
        tblock->last_ins = ins;
        D.30462 = tblock->last_ins;
        tblock->code = D.30462;
        <D.30465>:
        if (seq_points != 0) goto <D.30466>; else goto <D.30467>;
        <D.30466>:
        D.30412 = clause->flags;
        if (D.30412 != 2) goto <D.30468>; else goto <D.30469>;
        <D.30468>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 341;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        D.30414 = clause->handler_offset;
        D.30470 = (long int) D.30414;
        ins->data.op[1].const_val = D.30470;
        ins->flags = 1;
        D.30462 = tblock->last_ins;
        if (D.30462 != 0B) goto <D.30471>; else goto <D.30472>;
        <D.30471>:
        D.30462 = tblock->last_ins;
        D.30462->next = ins;
        D.30462 = tblock->last_ins;
        ins->prev = D.30462;
        tblock->last_ins = ins;
        goto <D.30473>;
        <D.30472>:
        tblock->last_ins = ins;
        D.30462 = tblock->last_ins;
        tblock->code = D.30462;
        <D.30473>:
        <D.30469>:
        <D.30467>:
        D.30412 = clause->flags;
        if (D.30412 == 4) goto <D.30474>; else goto <D.30475>;
        <D.30474>:
        D.30445 = tblock->flags;
        D.30476 = D.30445 | 8;
        tblock->flags = D.30476;
        <D.30475>:
        <D.30454>:
        D.30412 = clause->flags;
        if (D.30412 <= 1) goto <D.30477>; else goto <D.30478>;
        <D.30477>:
        {
          struct MonoInst * dummy_use;

          tblock->in_scount = 1;
          D.30241 = cfg->mempool;
          D.30479 = mono_mempool_alloc (D.30241, 8);
          tblock->in_stack = D.30479;
          D.30480 = tblock->in_stack;
          D.30414 = clause->handler_offset;
          D.30481 = (int) D.30414;
          D.30482 = mono_create_exvar_for_offset (cfg, D.30481);
          *D.30480 = D.30482;
          cfg->cbb = tblock;
          D.30241 = cfg->mempool;
          dummy_use = mono_mempool_alloc (D.30241, 80);
          dummy_use->data.op[1].const_val = 0;
          D.30483 = dummy_use->data.op[1].const_val;
          dummy_use->data.op[0].const_val = D.30483;
          dummy_use->prev = 0B;
          D.30484 = dummy_use->prev;
          dummy_use->next = D.30484;
          dummy_use->opcode = 796;
          dummy_use->flags = 0;
          dummy_use->type = 0;
          dummy_use->dreg = -1;
          dummy_use->sreg3 = -1;
          D.30485 = dummy_use->sreg3;
          dummy_use->sreg2 = D.30485;
          D.30486 = dummy_use->sreg2;
          dummy_use->sreg1 = D.30486;
          D.30461 = cfg->ip;
          dummy_use->cil_code = D.30461;
          D.30480 = tblock->in_stack;
          D.30487 = *D.30480;
          D.30488 = D.30487->dreg;
          dummy_use->sreg1 = D.30488;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.30491>; else goto <D.30492>;
          <D.30491>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = dummy_use;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          dummy_use->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = dummy_use;
          goto <D.30493>;
          <D.30492>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = dummy_use;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.30493>:
          D.30412 = clause->flags;
          if (D.30412 == 1) goto <D.30494>; else goto <D.30495>;
          <D.30494>:
          D.30372 = cfg->cil_offset_to_bb;
          D.30496 = clause->data.filter_offset;
          D.30497 = (sizetype) D.30496;
          D.30498 = ip + D.30497;
          D.30499 = (long int) D.30498;
          D.30377 = cfg->cil_start;
          D.30378 = (long int) D.30377;
          D.30500 = D.30499 - D.30378;
          D.30501 = (long unsigned int) D.30500;
          D.30502 = D.30501 * 8;
          D.30503 = D.30372 + D.30502;
          tblock = *D.30503;
          if (tblock == 0B) goto <D.30504>; else goto <D.30505>;
          <D.30504>:
          D.30496 = clause->data.filter_offset;
          D.30497 = (sizetype) D.30496;
          D.30498 = ip + D.30497;
          if (D.30498 >= end) goto <D.30506>; else goto <D.30508>;
          <D.30508>:
          D.30496 = clause->data.filter_offset;
          D.30497 = (sizetype) D.30496;
          D.30498 = ip + D.30497;
          D.30388 = header->code;
          if (D.30498 < D.30388) goto <D.30506>; else goto <D.30507>;
          <D.30506>:
          D.30389 = cfg->gsharedvt;
          if (D.30389 != 0) goto <D.30509>; else goto <D.30510>;
          <D.30509>:
          D.30322 = cfg->verbose_level;
          if (D.30322 > 2) goto <D.30511>; else goto <D.30512>;
          <D.30511>:
          printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
          <D.30512>:
          mono_cfg_set_exception (cfg, 11);
          goto exception_exit;
          <D.30510>:
          D.30513 = mini_get_debug_options ();
          D.30514 = D.30513->break_on_unverified;
          if (D.30514 != 0) goto <D.30515>; else goto unverified;
          <D.30515>:
          raise (5);
          <D.30507>:
          D.30241 = cfg->mempool;
          tblock = mono_mempool_alloc0 (D.30241, 296);
          D.30349 = cfg->num_bblocks;
          D.30516 = D.30349;
          D.30517 = D.30516 + 1;
          cfg->num_bblocks = D.30517;
          D.30518 = (int) D.30516;
          tblock->block_num = D.30518;
          D.30496 = clause->data.filter_offset;
          D.30497 = (sizetype) D.30496;
          D.30498 = ip + D.30497;
          tblock->cil_code = D.30498;
          D.30437 = tblock->cil_code;
          if (D.30437 != 0B) goto <D.30519>; else goto <D.30520>;
          <D.30519>:
          D.30372 = cfg->cil_offset_to_bb;
          D.30437 = tblock->cil_code;
          D.30440 = (long int) D.30437;
          D.30377 = cfg->cil_start;
          D.30378 = (long int) D.30377;
          D.30441 = D.30440 - D.30378;
          D.30442 = (long unsigned int) D.30441;
          D.30443 = D.30442 * 8;
          D.30444 = D.30372 + D.30443;
          *D.30444 = tblock;
          <D.30520>:
          D.30408 = cfg->real_offset;
          tblock->real_offset = D.30408;
          <D.30505>:
          D.30445 = tblock->flags;
          D.30446 = D.30445 | 16;
          tblock->flags = D.30446;
          D.30496 = clause->data.filter_offset;
          tblock->real_offset = D.30496;
          tblock->in_scount = 1;
          D.30241 = cfg->mempool;
          D.30521 = mono_mempool_alloc (D.30241, 8);
          tblock->in_stack = D.30521;
          D.30480 = tblock->in_stack;
          D.30414 = clause->handler_offset;
          D.30481 = (int) D.30414;
          D.30522 = mono_create_exvar_for_offset (cfg, D.30481);
          *D.30480 = D.30522;
          D.30241 = cfg->mempool;
          ins = mono_mempool_alloc (D.30241, 80);
          ins->data.op[1].const_val = 0;
          D.30457 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.30457;
          ins->prev = 0B;
          D.30458 = ins->prev;
          ins->next = D.30458;
          ins->opcode = 736;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.30459 = ins->sreg3;
          ins->sreg2 = D.30459;
          D.30460 = ins->sreg2;
          ins->sreg1 = D.30460;
          D.30461 = cfg->ip;
          ins->cil_code = D.30461;
          D.30462 = tblock->last_ins;
          if (D.30462 != 0B) goto <D.30523>; else goto <D.30524>;
          <D.30523>:
          D.30462 = tblock->last_ins;
          D.30462->next = ins;
          D.30462 = tblock->last_ins;
          ins->prev = D.30462;
          tblock->last_ins = ins;
          goto <D.30525>;
          <D.30524>:
          tblock->last_ins = ins;
          D.30462 = tblock->last_ins;
          tblock->code = D.30462;
          <D.30525>:
          <D.30495>:
        }
        <D.30478>:
        D.30412 = clause->flags;
        if (D.30412 != 1) goto <D.30526>; else goto <D.30527>;
        <D.30526>:
        D.30528 = clause->data.catch_class;
        if (D.30528 != 0B) goto <D.30529>; else goto <D.30530>;
        <D.30529>:
        D.30278 = cfg->generic_sharing_context;
        if (D.30278 != 0B) goto <D.30531>; else goto <D.30532>;
        <D.30531>:
        D.30528 = clause->data.catch_class;
        D.30533 = mono_class_check_context_used (D.30528);
        if (D.30533 != 0) goto <D.30534>; else goto <D.30535>;
        <D.30534>:
        D.30539 = method->flags;
        D.30540 = (int) D.30539;
        D.30541 = D.30540 & 16;
        if (D.30541 != 0) goto <D.30536>; else goto <D.30542>;
        <D.30542>:
        D.30543 = mini_method_get_context (method);
        D.30544 = D.30543->method_inst;
        if (D.30544 != 0B) goto <D.30536>; else goto <D.30545>;
        <D.30545>:
        D.30178 = method->klass;
        D.30331 = BIT_FIELD_REF <*D.30178, 64, 256>;
        D.30332 = D.30331 & 1152921504606846976;
        if (D.30332 != 0) goto <D.30536>; else goto <D.30537>;
        <D.30536>:
        mono_get_vtable_var (cfg);
        goto <D.30538>;
        <D.30537>:
        {
          struct MonoInst * dummy_use;

          D.30241 = cfg->mempool;
          dummy_use = mono_mempool_alloc (D.30241, 80);
          dummy_use->data.op[1].const_val = 0;
          D.30546 = dummy_use->data.op[1].const_val;
          dummy_use->data.op[0].const_val = D.30546;
          dummy_use->prev = 0B;
          D.30547 = dummy_use->prev;
          dummy_use->next = D.30547;
          dummy_use->opcode = 796;
          dummy_use->flags = 0;
          dummy_use->type = 0;
          dummy_use->dreg = -1;
          dummy_use->sreg3 = -1;
          D.30548 = dummy_use->sreg3;
          dummy_use->sreg2 = D.30548;
          D.30549 = dummy_use->sreg2;
          dummy_use->sreg1 = D.30549;
          D.30461 = cfg->ip;
          dummy_use->cil_code = D.30461;
          D.30550 = *arg_array;
          D.30551 = D.30550->dreg;
          dummy_use->sreg1 = D.30551;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.30552>; else goto <D.30553>;
          <D.30552>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = dummy_use;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          dummy_use->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = dummy_use;
          goto <D.30554>;
          <D.30553>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = dummy_use;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.30554>:
        }
        <D.30538>:
        <D.30535>:
        <D.30532>:
        <D.30530>:
        <D.30527>:
      }
      i = i + 1;
      <D.27358>:
      D.30555 = header->num_clauses;
      D.30556 = (int) D.30555;
      if (D.30556 > i) goto <D.27357>; else goto <D.27359>;
      <D.27359>:
      goto <D.30557>;
      <D.30342>:
      D.30558 = (long unsigned int) num_args;
      D.30559 = D.30558 * 8;
      arg_array = __builtin_alloca (D.30559);
      cfg->cbb = start_bblock;
      cfg->args = arg_array;
      mono_save_args (cfg, sig, inline_args);
      <D.30557>:
      D.30241 = cfg->mempool;
      bblock.63 = mono_mempool_alloc0 (D.30241, 296);
      bblock = bblock.63;
      bblock.64 = bblock;
      D.30349 = cfg->num_bblocks;
      D.30562 = D.30349;
      D.30563 = D.30562 + 1;
      cfg->num_bblocks = D.30563;
      D.30564 = (int) D.30562;
      bblock.64->block_num = D.30564;
      bblock.64 = bblock;
      bblock.64->cil_code = ip;
      bblock.64 = bblock;
      cfg->cbb = bblock.64;
      cfg->ip = ip;
      bblock.64 = bblock;
      D.30565 = bblock.64->cil_code;
      if (D.30565 != 0B) goto <D.30566>; else goto <D.30567>;
      <D.30566>:
      D.30372 = cfg->cil_offset_to_bb;
      bblock.64 = bblock;
      D.30565 = bblock.64->cil_code;
      D.30568 = (long int) D.30565;
      D.30377 = cfg->cil_start;
      D.30378 = (long int) D.30377;
      D.30569 = D.30568 - D.30378;
      D.30570 = (long unsigned int) D.30569;
      D.30571 = D.30570 * 8;
      D.30572 = D.30372 + D.30571;
      bblock.64 = bblock;
      *D.30572 = bblock.64;
      <D.30567>:
      bblock.64 = bblock;
      D.30408 = cfg->real_offset;
      bblock.64->real_offset = D.30408;
      D.30211 = cfg->method;
      if (D.30211 == method) goto <D.30573>; else goto <D.30574>;
      <D.30573>:
      breakpoint_id = mono_debugger_method_has_breakpoint (method);
      if (breakpoint_id != 0) goto <D.30575>; else goto <D.30576>;
      <D.30575>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 445;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      if (D.30577 != 0B) goto <D.30578>; else goto <D.30579>;
      <D.30578>:
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      D.30577->next = ins;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      ins->prev = D.30577;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      goto <D.30580>;
      <D.30579>:
      bblock.64 = bblock;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      D.30577 = bblock.64->last_ins;
      bblock.64->code = D.30577;
      <D.30580>:
      <D.30576>:
      <D.30574>:
      D.30581 = mono_security_get_mode ();
      if (D.30581 == 2) goto <D.30582>; else goto <D.30583>;
      <D.30582>:
      secman = mono_security_manager_get_methods ();
      <D.30583>:
      if (secman != 0B) goto <D.30587>; else goto <D.30585>;
      <D.30587>:
      D.30588 = mono_method_has_declsec (method);
      if (D.30588 != 0) goto <D.30589>; else goto <D.30585>;
      <D.30589>:
      iftmp.65 = 1;
      goto <D.30586>;
      <D.30585>:
      iftmp.65 = 0;
      <D.30586>:
      security = (MonoBoolean) iftmp.65;
      if (security != 0) goto <D.30590>; else goto <D.30591>;
      <D.30590>:
      D.30211 = cfg->method;
      if (D.30211 == method) goto <D.30592>; else goto <D.30593>;
      <D.30592>:
      security = mono_declsec_get_demands (method, &actions);
      <D.30593>:
      <D.30591>:
      if (secman != 0B) goto <D.30597>; else goto <D.30595>;
      <D.30597>:
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30184 = D.30183 & 4467570830351532032;
      if (D.30184 == 864691128455135232) goto <D.30598>; else goto <D.30595>;
      <D.30598>:
      iftmp.66 = 1;
      goto <D.30596>;
      <D.30595>:
      iftmp.66 = 0;
      <D.30596>:
      pinvoke = (MonoBoolean) iftmp.66;
      if (pinvoke != 0) goto <D.30599>; else goto <D.30600>;
      <D.30599>:
      {
        struct MonoMethod * wrapped;

        wrapped = mono_marshal_method_from_wrapper (method);
        if (wrapped != 0B) goto <D.30603>; else goto <D.30601>;
        <D.30603>:
        D.30604 = wrapped->flags;
        D.30605 = (int) D.30604;
        D.30606 = D.30605 & 8192;
        if (D.30606 != 0) goto <D.30607>; else goto <D.30601>;
        <D.30607>:
        {
          struct MonoCustomAttrInfo * custom;

          custom = mono_custom_attrs_from_method (wrapped);
          if (custom != 0B) goto <D.30608>; else goto <D.30609>;
          <D.30608>:
          D.30610 = secman->suppressunmanagedcodesecurity;
          D.30611 = mono_custom_attrs_has_attr (custom, D.30610);
          if (D.30611 != 0) goto <D.30612>; else goto <D.30613>;
          <D.30612>:
          pinvoke = 0;
          <D.30613>:
          <D.30609>:
          if (custom != 0B) goto <D.30614>; else goto <D.30615>;
          <D.30614>:
          mono_custom_attrs_free (custom);
          <D.30615>:
          if (pinvoke != 0) goto <D.30616>; else goto <D.30617>;
          <D.30616>:
          D.30618 = wrapped->klass;
          custom = mono_custom_attrs_from_class (D.30618);
          if (custom != 0B) goto <D.30619>; else goto <D.30620>;
          <D.30619>:
          D.30610 = secman->suppressunmanagedcodesecurity;
          D.30621 = mono_custom_attrs_has_attr (custom, D.30610);
          if (D.30621 != 0) goto <D.30622>; else goto <D.30623>;
          <D.30622>:
          pinvoke = 0;
          <D.30623>:
          <D.30620>:
          if (custom != 0B) goto <D.30624>; else goto <D.30625>;
          <D.30624>:
          mono_custom_attrs_free (custom);
          <D.30625>:
          <D.30617>:
        }
        goto <D.30602>;
        <D.30601>:
        pinvoke = 0;
        <D.30602>:
      }
      <D.30600>:
      if (init_locals != 0) goto <D.30626>; else goto <D.30630>;
      <D.30630>:
      D.30211 = cfg->method;
      if (D.30211 == method) goto <D.30631>; else goto <D.30627>;
      <D.30631>:
      D.30632 = cfg->opt;
      D.30633 = D.30632 & 512;
      if (D.30633 != 0) goto <D.30626>; else goto <D.30627>;
      <D.30627>:
      D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.30635 = D.30634 & 33554432;
      if (D.30635 != 0) goto <D.30626>; else goto <D.30636>;
      <D.30636>:
      if (security != 0) goto <D.30626>; else goto <D.30637>;
      <D.30637>:
      if (pinvoke != 0) goto <D.30626>; else goto <D.30628>;
      <D.30626>:
      D.30241 = cfg->mempool;
      init_localsbb = mono_mempool_alloc0 (D.30241, 296);
      D.30349 = cfg->num_bblocks;
      D.30638 = D.30349;
      D.30639 = D.30638 + 1;
      cfg->num_bblocks = D.30639;
      D.30640 = (int) D.30638;
      init_localsbb->block_num = D.30640;
      cfg->bb_init = init_localsbb;
      D.30408 = cfg->real_offset;
      init_localsbb->real_offset = D.30408;
      start_bblock->next_bb = init_localsbb;
      bblock.64 = bblock;
      init_localsbb->next_bb = bblock.64;
      link_bblock (cfg, start_bblock, init_localsbb);
      bblock.64 = bblock;
      link_bblock (cfg, init_localsbb, bblock.64);
      cfg->cbb = init_localsbb;
      goto <D.30629>;
      <D.30628>:
      bblock.64 = bblock;
      start_bblock->next_bb = bblock.64;
      bblock.64 = bblock;
      link_bblock (cfg, start_bblock, bblock.64);
      <D.30629>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.30641>; else goto <D.30642>;
      <D.30641>:
      D.30211 = cfg->method;
      if (D.30211 == method) goto <D.30643>; else goto <D.30644>;
      <D.30643>:
      {
        struct MonoGSharedVtMethodInfo * info;
        struct MonoInst * var;
        struct MonoInst * locals_var;
        int dreg;

        D.30241 = cfg->mempool;
        info = mono_mempool_alloc0 (D.30241, 16);
        D.30211 = cfg->method;
        info->method = D.30211;
        D.30645 = monoeg_g_ptr_array_new ();
        info->entries = D.30645;
        cfg->gsharedvt_info = info;
        D.30646 = mono_defaults.int_class;
        D.30647 = &D.30646->byval_arg;
        var = mono_compile_create_var (cfg, D.30647, 329);
        cfg->gsharedvt_info_var = var;
        D.30648 = mini_method_check_context_used (cfg, method);
        ins = emit_get_rgctx_gsharedvt_method (cfg, D.30648, method, info);
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.30649 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.30649;
          inst->prev = 0B;
          D.30650 = inst->prev;
          inst->next = D.30650;
          inst->opcode = 424;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.30651 = inst->sreg3;
          inst->sreg2 = D.30651;
          D.30652 = inst->sreg2;
          inst->sreg1 = D.30652;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          D.30653 = var->dreg;
          inst->dreg = D.30653;
          D.30654 = ins->dreg;
          inst->sreg1 = D.30654;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.30655>; else goto <D.30656>;
          <D.30655>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.30657>;
          <D.30656>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.30657>:
        }
        D.30646 = mono_defaults.int_class;
        D.30647 = &D.30646->byval_arg;
        locals_var = mono_compile_create_var (cfg, D.30647, 329);
        cfg->gsharedvt_locals_var = locals_var;
        D.30658 = alloc_ireg (cfg);
        dreg = (int) D.30658;
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.30659 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.30659;
          inst->prev = 0B;
          D.30660 = inst->prev;
          inst->next = D.30660;
          inst->opcode = 393;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.30661 = inst->sreg3;
          inst->sreg2 = D.30661;
          D.30662 = inst->sreg2;
          inst->sreg1 = D.30662;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          inst->dreg = dreg;
          D.30653 = var->dreg;
          inst->sreg1 = D.30653;
          inst->data.op[0].const_val = 0;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.30663>; else goto <D.30664>;
          <D.30663>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.30665>;
          <D.30664>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.30665>:
        }
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 338;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        D.30666 = locals_var->dreg;
        ins->dreg = D.30666;
        ins->sreg1 = dreg;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.30667>; else goto <D.30668>;
        <D.30667>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.30669>;
        <D.30668>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.30669>:
        cfg->gsharedvt_locals_var_ins = ins;
        D.30670 = cfg->flags;
        D.30671 = D.30670 | 1;
        cfg->flags = D.30671;
      }
      <D.30644>:
      <D.30642>:
      if (security != 0) goto <D.30672>; else goto <D.30673>;
      <D.30672>:
      D.30211 = cfg->method;
      if (D.30211 == method) goto <D.30674>; else goto <D.30675>;
      <D.30674>:
      {
        struct MonoInst * args[2];

        try
          {
            D.30676 = cfg->stat_cas_demand_generation;
            D.30677 = D.30676 + 1;
            cfg->stat_cas_demand_generation = D.30677;
            D.30678 = actions.demand.blob;
            if (D.30678 != 0B) goto <D.30679>; else goto <D.30680>;
            <D.30679>:
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.30681>; else goto <D.30682>;
            <D.30681>:
            D.30241 = cfg->mempool;
            D.30683 = mono_mempool_alloc (D.30241, 80);
            args[0] = D.30683;
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684->data.op[1].const_val = 0;
            D.30685 = D.30684->data.op[1].const_val;
            D.30684->data.op[0].const_val = D.30685;
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684->prev = 0B;
            D.30686 = D.30684->prev;
            D.30684->next = D.30686;
            D.30684 = args[0];
            D.30684->opcode = 732;
            D.30684 = args[0];
            D.30684->flags = 0;
            D.30684 = args[0];
            D.30684->type = 0;
            D.30684 = args[0];
            D.30684->dreg = -1;
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684->sreg3 = -1;
            D.30687 = D.30684->sreg3;
            D.30684->sreg2 = D.30687;
            D.30688 = D.30684->sreg2;
            D.30684->sreg1 = D.30688;
            D.30684 = args[0];
            D.30461 = cfg->ip;
            D.30684->cil_code = D.30461;
            D.30684 = args[0];
            D.30241 = cfg->mempool;
            D.30689 = actions.demand.index;
            D.30690 = mono_jump_info_token_new2 (D.30241, image, D.30689, 0B);
            D.30684->data.op[0].p = D.30690;
            D.30684 = args[0];
            D.30684->data.op[1].p = 28B;
            D.30684 = args[0];
            D.30684->type = 6;
            D.30684 = args[0];
            D.30684->klass = 0B;
            D.30684 = args[0];
            D.30691 = alloc_dreg (cfg, 6);
            D.30692 = (int) D.30691;
            D.30684->dreg = D.30692;
            goto <D.30693>;
            <D.30682>:
            D.30241 = cfg->mempool;
            D.30694 = mono_mempool_alloc (D.30241, 80);
            args[0] = D.30694;
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684->data.op[1].const_val = 0;
            D.30685 = D.30684->data.op[1].const_val;
            D.30684->data.op[0].const_val = D.30685;
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684->prev = 0B;
            D.30686 = D.30684->prev;
            D.30684->next = D.30686;
            D.30684 = args[0];
            D.30684->opcode = 363;
            D.30684 = args[0];
            D.30684->flags = 0;
            D.30684 = args[0];
            D.30684->type = 0;
            D.30684 = args[0];
            D.30684->dreg = -1;
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684->sreg3 = -1;
            D.30687 = D.30684->sreg3;
            D.30684->sreg2 = D.30687;
            D.30688 = D.30684->sreg2;
            D.30684->sreg1 = D.30688;
            D.30684 = args[0];
            D.30461 = cfg->ip;
            D.30684->cil_code = D.30461;
            D.30684 = args[0];
            D.30678 = actions.demand.blob;
            D.30684->data.op[0].p = D.30678;
            D.30684 = args[0];
            D.30684->type = 3;
            D.30684 = args[0];
            D.30695 = alloc_dreg (cfg, 3);
            D.30696 = (int) D.30695;
            D.30684->dreg = D.30696;
            <D.30693>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.30697>; else goto <D.30698>;
            <D.30697>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30684 = args[0];
            D.30490->next = D.30684;
            D.30684 = args[0];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30684->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.30684 = args[0];
            bblock.106->last_ins = D.30684;
            goto <D.30699>;
            <D.30698>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.30684 = args[0];
            bblock.106->last_ins = D.30684;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.30699>:
            D.30241 = cfg->mempool;
            D.30700 = mono_mempool_alloc (D.30241, 80);
            args[1] = D.30700;
            D.30701 = args[1];
            D.30701 = args[1];
            D.30701->data.op[1].const_val = 0;
            D.30702 = D.30701->data.op[1].const_val;
            D.30701->data.op[0].const_val = D.30702;
            D.30701 = args[1];
            D.30701 = args[1];
            D.30701->prev = 0B;
            D.30703 = D.30701->prev;
            D.30701->next = D.30703;
            D.30701 = args[1];
            D.30701->opcode = 362;
            D.30701 = args[1];
            D.30701->flags = 0;
            D.30701 = args[1];
            D.30701->type = 0;
            D.30701 = args[1];
            D.30701->dreg = -1;
            D.30701 = args[1];
            D.30701 = args[1];
            D.30701 = args[1];
            D.30701->sreg3 = -1;
            D.30704 = D.30701->sreg3;
            D.30701->sreg2 = D.30704;
            D.30705 = D.30701->sreg2;
            D.30701->sreg1 = D.30705;
            D.30701 = args[1];
            D.30461 = cfg->ip;
            D.30701->cil_code = D.30461;
            D.30701 = args[1];
            D.30706 = actions.demand.size;
            D.30707 = (long int) D.30706;
            D.30701->data.op[0].const_val = D.30707;
            D.30701 = args[1];
            D.30701->type = 1;
            D.30701 = args[1];
            D.30708 = alloc_dreg (cfg, 1);
            D.30709 = (int) D.30708;
            D.30701->dreg = D.30709;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.30710>; else goto <D.30711>;
            <D.30710>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30701 = args[1];
            D.30490->next = D.30701;
            D.30701 = args[1];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30701->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.30701 = args[1];
            bblock.106->last_ins = D.30701;
            goto <D.30712>;
            <D.30711>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.30701 = args[1];
            bblock.106->last_ins = D.30701;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.30712>:
            D.30713 = secman->demand;
            mono_emit_method_call (cfg, D.30713, &args, 0B);
            <D.30680>:
            D.30714 = actions.noncasdemand.blob;
            if (D.30714 != 0B) goto <D.30715>; else goto <D.30716>;
            <D.30715>:
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.30717>; else goto <D.30718>;
            <D.30717>:
            D.30241 = cfg->mempool;
            D.30719 = mono_mempool_alloc (D.30241, 80);
            args[0] = D.30719;
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684->data.op[1].const_val = 0;
            D.30685 = D.30684->data.op[1].const_val;
            D.30684->data.op[0].const_val = D.30685;
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684->prev = 0B;
            D.30686 = D.30684->prev;
            D.30684->next = D.30686;
            D.30684 = args[0];
            D.30684->opcode = 732;
            D.30684 = args[0];
            D.30684->flags = 0;
            D.30684 = args[0];
            D.30684->type = 0;
            D.30684 = args[0];
            D.30684->dreg = -1;
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684->sreg3 = -1;
            D.30687 = D.30684->sreg3;
            D.30684->sreg2 = D.30687;
            D.30688 = D.30684->sreg2;
            D.30684->sreg1 = D.30688;
            D.30684 = args[0];
            D.30461 = cfg->ip;
            D.30684->cil_code = D.30461;
            D.30684 = args[0];
            D.30241 = cfg->mempool;
            D.30720 = actions.noncasdemand.index;
            D.30721 = mono_jump_info_token_new2 (D.30241, image, D.30720, 0B);
            D.30684->data.op[0].p = D.30721;
            D.30684 = args[0];
            D.30684->data.op[1].p = 28B;
            D.30684 = args[0];
            D.30684->type = 6;
            D.30684 = args[0];
            D.30684->klass = 0B;
            D.30684 = args[0];
            D.30722 = alloc_dreg (cfg, 6);
            D.30723 = (int) D.30722;
            D.30684->dreg = D.30723;
            goto <D.30724>;
            <D.30718>:
            D.30241 = cfg->mempool;
            D.30725 = mono_mempool_alloc (D.30241, 80);
            args[0] = D.30725;
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684->data.op[1].const_val = 0;
            D.30685 = D.30684->data.op[1].const_val;
            D.30684->data.op[0].const_val = D.30685;
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684->prev = 0B;
            D.30686 = D.30684->prev;
            D.30684->next = D.30686;
            D.30684 = args[0];
            D.30684->opcode = 363;
            D.30684 = args[0];
            D.30684->flags = 0;
            D.30684 = args[0];
            D.30684->type = 0;
            D.30684 = args[0];
            D.30684->dreg = -1;
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684->sreg3 = -1;
            D.30687 = D.30684->sreg3;
            D.30684->sreg2 = D.30687;
            D.30688 = D.30684->sreg2;
            D.30684->sreg1 = D.30688;
            D.30684 = args[0];
            D.30461 = cfg->ip;
            D.30684->cil_code = D.30461;
            D.30684 = args[0];
            D.30714 = actions.noncasdemand.blob;
            D.30684->data.op[0].p = D.30714;
            D.30684 = args[0];
            D.30684->type = 3;
            D.30684 = args[0];
            D.30726 = alloc_dreg (cfg, 3);
            D.30727 = (int) D.30726;
            D.30684->dreg = D.30727;
            <D.30724>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.30728>; else goto <D.30729>;
            <D.30728>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30684 = args[0];
            D.30490->next = D.30684;
            D.30684 = args[0];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30684->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.30684 = args[0];
            bblock.106->last_ins = D.30684;
            goto <D.30730>;
            <D.30729>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.30684 = args[0];
            bblock.106->last_ins = D.30684;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.30730>:
            D.30241 = cfg->mempool;
            D.30731 = mono_mempool_alloc (D.30241, 80);
            args[1] = D.30731;
            D.30701 = args[1];
            D.30701 = args[1];
            D.30701->data.op[1].const_val = 0;
            D.30702 = D.30701->data.op[1].const_val;
            D.30701->data.op[0].const_val = D.30702;
            D.30701 = args[1];
            D.30701 = args[1];
            D.30701->prev = 0B;
            D.30703 = D.30701->prev;
            D.30701->next = D.30703;
            D.30701 = args[1];
            D.30701->opcode = 362;
            D.30701 = args[1];
            D.30701->flags = 0;
            D.30701 = args[1];
            D.30701->type = 0;
            D.30701 = args[1];
            D.30701->dreg = -1;
            D.30701 = args[1];
            D.30701 = args[1];
            D.30701 = args[1];
            D.30701->sreg3 = -1;
            D.30704 = D.30701->sreg3;
            D.30701->sreg2 = D.30704;
            D.30705 = D.30701->sreg2;
            D.30701->sreg1 = D.30705;
            D.30701 = args[1];
            D.30461 = cfg->ip;
            D.30701->cil_code = D.30461;
            D.30701 = args[1];
            D.30732 = actions.noncasdemand.size;
            D.30733 = (long int) D.30732;
            D.30701->data.op[0].const_val = D.30733;
            D.30701 = args[1];
            D.30701->type = 1;
            D.30701 = args[1];
            D.30734 = alloc_dreg (cfg, 1);
            D.30735 = (int) D.30734;
            D.30701->dreg = D.30735;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.30736>; else goto <D.30737>;
            <D.30736>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30701 = args[1];
            D.30490->next = D.30701;
            D.30701 = args[1];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30701->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.30701 = args[1];
            bblock.106->last_ins = D.30701;
            goto <D.30738>;
            <D.30737>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.30701 = args[1];
            bblock.106->last_ins = D.30701;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.30738>:
            D.30713 = secman->demand;
            mono_emit_method_call (cfg, D.30713, &args, 0B);
            <D.30716>:
            D.30739 = actions.demandchoice.blob;
            if (D.30739 != 0B) goto <D.30740>; else goto <D.30741>;
            <D.30740>:
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.30742>; else goto <D.30743>;
            <D.30742>:
            D.30241 = cfg->mempool;
            D.30744 = mono_mempool_alloc (D.30241, 80);
            args[0] = D.30744;
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684->data.op[1].const_val = 0;
            D.30685 = D.30684->data.op[1].const_val;
            D.30684->data.op[0].const_val = D.30685;
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684->prev = 0B;
            D.30686 = D.30684->prev;
            D.30684->next = D.30686;
            D.30684 = args[0];
            D.30684->opcode = 732;
            D.30684 = args[0];
            D.30684->flags = 0;
            D.30684 = args[0];
            D.30684->type = 0;
            D.30684 = args[0];
            D.30684->dreg = -1;
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684->sreg3 = -1;
            D.30687 = D.30684->sreg3;
            D.30684->sreg2 = D.30687;
            D.30688 = D.30684->sreg2;
            D.30684->sreg1 = D.30688;
            D.30684 = args[0];
            D.30461 = cfg->ip;
            D.30684->cil_code = D.30461;
            D.30684 = args[0];
            D.30241 = cfg->mempool;
            D.30745 = actions.demandchoice.index;
            D.30746 = mono_jump_info_token_new2 (D.30241, image, D.30745, 0B);
            D.30684->data.op[0].p = D.30746;
            D.30684 = args[0];
            D.30684->data.op[1].p = 28B;
            D.30684 = args[0];
            D.30684->type = 6;
            D.30684 = args[0];
            D.30684->klass = 0B;
            D.30684 = args[0];
            D.30747 = alloc_dreg (cfg, 6);
            D.30748 = (int) D.30747;
            D.30684->dreg = D.30748;
            goto <D.30749>;
            <D.30743>:
            D.30241 = cfg->mempool;
            D.30750 = mono_mempool_alloc (D.30241, 80);
            args[0] = D.30750;
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684->data.op[1].const_val = 0;
            D.30685 = D.30684->data.op[1].const_val;
            D.30684->data.op[0].const_val = D.30685;
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684->prev = 0B;
            D.30686 = D.30684->prev;
            D.30684->next = D.30686;
            D.30684 = args[0];
            D.30684->opcode = 363;
            D.30684 = args[0];
            D.30684->flags = 0;
            D.30684 = args[0];
            D.30684->type = 0;
            D.30684 = args[0];
            D.30684->dreg = -1;
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684 = args[0];
            D.30684->sreg3 = -1;
            D.30687 = D.30684->sreg3;
            D.30684->sreg2 = D.30687;
            D.30688 = D.30684->sreg2;
            D.30684->sreg1 = D.30688;
            D.30684 = args[0];
            D.30461 = cfg->ip;
            D.30684->cil_code = D.30461;
            D.30684 = args[0];
            D.30739 = actions.demandchoice.blob;
            D.30684->data.op[0].p = D.30739;
            D.30684 = args[0];
            D.30684->type = 3;
            D.30684 = args[0];
            D.30751 = alloc_dreg (cfg, 3);
            D.30752 = (int) D.30751;
            D.30684->dreg = D.30752;
            <D.30749>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.30753>; else goto <D.30754>;
            <D.30753>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30684 = args[0];
            D.30490->next = D.30684;
            D.30684 = args[0];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30684->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.30684 = args[0];
            bblock.106->last_ins = D.30684;
            goto <D.30755>;
            <D.30754>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.30684 = args[0];
            bblock.106->last_ins = D.30684;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.30755>:
            D.30241 = cfg->mempool;
            D.30756 = mono_mempool_alloc (D.30241, 80);
            args[1] = D.30756;
            D.30701 = args[1];
            D.30701 = args[1];
            D.30701->data.op[1].const_val = 0;
            D.30702 = D.30701->data.op[1].const_val;
            D.30701->data.op[0].const_val = D.30702;
            D.30701 = args[1];
            D.30701 = args[1];
            D.30701->prev = 0B;
            D.30703 = D.30701->prev;
            D.30701->next = D.30703;
            D.30701 = args[1];
            D.30701->opcode = 362;
            D.30701 = args[1];
            D.30701->flags = 0;
            D.30701 = args[1];
            D.30701->type = 0;
            D.30701 = args[1];
            D.30701->dreg = -1;
            D.30701 = args[1];
            D.30701 = args[1];
            D.30701 = args[1];
            D.30701->sreg3 = -1;
            D.30704 = D.30701->sreg3;
            D.30701->sreg2 = D.30704;
            D.30705 = D.30701->sreg2;
            D.30701->sreg1 = D.30705;
            D.30701 = args[1];
            D.30461 = cfg->ip;
            D.30701->cil_code = D.30461;
            D.30701 = args[1];
            D.30757 = actions.demandchoice.size;
            D.30758 = (long int) D.30757;
            D.30701->data.op[0].const_val = D.30758;
            D.30701 = args[1];
            D.30701->type = 1;
            D.30701 = args[1];
            D.30759 = alloc_dreg (cfg, 1);
            D.30760 = (int) D.30759;
            D.30701->dreg = D.30760;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.30761>; else goto <D.30762>;
            <D.30761>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30701 = args[1];
            D.30490->next = D.30701;
            D.30701 = args[1];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30701->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.30701 = args[1];
            bblock.106->last_ins = D.30701;
            goto <D.30763>;
            <D.30762>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.30701 = args[1];
            bblock.106->last_ins = D.30701;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.30763>:
            D.30764 = secman->demandchoice;
            mono_emit_method_call (cfg, D.30764, &args, 0B);
            <D.30741>:
          }
        finally
          {
            args = {CLOBBER};
          }
      }
      <D.30675>:
      <D.30673>:
      if (pinvoke != 0) goto <D.30765>; else goto <D.30766>;
      <D.30765>:
      D.30767 = secman->demandunmanaged;
      mono_emit_method_call (cfg, D.30767, 0B, 0B);
      <D.30766>:
      D.30768 = mono_security_get_mode ();
      if (D.30768 == 1) goto <D.30769>; else goto <D.30770>;
      <D.30769>:
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30184 = D.30183 & 4467570830351532032;
      if (D.30184 == 864691128455135232) goto <D.30771>; else goto <D.30772>;
      <D.30771>:
      {
        struct MonoMethod * wrapped;

        wrapped = mono_marshal_method_from_wrapper (method);
        if (wrapped != 0B) goto <D.30773>; else goto <D.30774>;
        <D.30773>:
        {
          gboolean pinvk;
          gboolean icall;

          D.30775 = wrapped->flags;
          D.30776 = (int) D.30775;
          pinvk = D.30776 & 8192;
          D.30777 = wrapped->iflags;
          D.30778 = (int) D.30777;
          icall = D.30778 & 4096;
          if (icall != 0) goto <D.30779>; else goto <D.30781>;
          <D.30781>:
          if (pinvk != 0) goto <D.30779>; else goto <D.30780>;
          <D.30779>:
          D.30178 = method->klass;
          if (D.30178 != 0B) goto <D.30782>; else goto <D.30783>;
          <D.30782>:
          D.30178 = method->klass;
          D.30179 = D.30178->image;
          if (D.30179 != 0B) goto <D.30784>; else goto <D.30785>;
          <D.30784>:
          D.30178 = method->klass;
          D.30179 = D.30178->image;
          D.30786 = mono_security_core_clr_is_platform_image (D.30179);
          if (D.30786 == 0) goto <D.30787>; else goto <D.30788>;
          <D.30787>:
          {
            struct MonoException * ex;

            if (icall != 0) goto <D.30790>; else goto <D.30791>;
            <D.30790>:
            iftmp.67 = mono_get_exception_security ();
            goto <D.30792>;
            <D.30791>:
            iftmp.67 = mono_get_exception_method_access ();
            <D.30792>:
            ex = iftmp.67;
            emit_throw_exception (cfg, ex);
          }
          <D.30788>:
          <D.30785>:
          <D.30783>:
          <D.30780>:
        }
        <D.30774>:
      }
      <D.30772>:
      <D.30770>:
      D.30793 = cfg->exception_type;
      if (D.30793 != 0) goto exception_exit; else goto <D.30794>;
      <D.30794>:
      D.30219 = header->code_size;
      if (D.30219 == 0) goto <D.30795>; else goto <D.30796>;
      <D.30795>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.30797>; else goto <D.30798>;
      <D.30797>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.30799>; else goto <D.30800>;
      <D.30799>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.30800>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.30798>:
      D.30801 = mini_get_debug_options ();
      D.30802 = D.30801->break_on_unverified;
      if (D.30802 != 0) goto <D.30803>; else goto unverified;
      <D.30803>:
      raise (5);
      <D.30796>:
      D.30408 = cfg->real_offset;
      D.30804 = get_basic_blocks (cfg, header, D.30408, ip, end, &err_pos);
      if (D.30804 != 0) goto <D.30805>; else goto <D.30806>;
      <D.30805>:
      ip = err_pos;
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.30807>; else goto <D.30808>;
      <D.30807>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.30809>; else goto <D.30810>;
      <D.30809>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.30810>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.30808>:
      D.30811 = mini_get_debug_options ();
      D.30812 = D.30811->break_on_unverified;
      if (D.30812 != 0) goto <D.30813>; else goto unverified;
      <D.30813>:
      raise (5);
      <D.30806>:
      D.30211 = cfg->method;
      if (D.30211 == method) goto <D.30814>; else goto <D.30815>;
      <D.30814>:
      bblock.64 = bblock;
      breakpoint_id.68 = (unsigned int) breakpoint_id;
      mono_debug_init_method (cfg, bblock.64, breakpoint_id.68);
      <D.30815>:
      n = 0;
      goto <D.27374>;
      <D.27373>:
      D.30817 = header->locals[n];
      D.30818 = BIT_FIELD_REF <*D.30817, 64, 64>;
      D.30819 = D.30818 & 280384055017472;
      if (D.30819 == 1099511627776) goto <D.30820>; else goto <D.30821>;
      <D.30820>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.30822>; else goto <D.30823>;
      <D.30822>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.30824>; else goto <D.30825>;
      <D.30824>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.30825>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.30823>:
      D.30826 = mini_get_debug_options ();
      D.30827 = D.30826->break_on_unverified;
      if (D.30827 != 0) goto <D.30828>; else goto unverified;
      <D.30828>:
      raise (5);
      <D.30821>:
      n = n + 1;
      <D.27374>:
      D.30829 = header->num_locals;
      D.30830 = (int) D.30829;
      if (D.30830 > n) goto <D.27373>; else goto <D.27375>;
      <D.27375>:
      class_inits = 0B;
      D.30278 = cfg->generic_sharing_context;
      if (D.30278 != 0B) goto <D.30831>; else goto <D.30832>;
      <D.30831>:
      D.30211 = cfg->method;
      if (D.30211 == method) goto <D.30833>; else goto <D.30834>;
      <D.30833>:
      D.30539 = method->flags;
      D.30540 = (int) D.30539;
      D.30541 = D.30540 & 16;
      if (D.30541 != 0) goto <D.30835>; else goto <D.30838>;
      <D.30838>:
      D.30839 = mini_method_get_context (method);
      D.30840 = D.30839->method_inst;
      if (D.30840 != 0B) goto <D.30835>; else goto <D.30841>;
      <D.30841>:
      D.30178 = method->klass;
      D.30331 = BIT_FIELD_REF <*D.30178, 64, 256>;
      D.30332 = D.30331 & 1152921504606846976;
      if (D.30332 != 0) goto <D.30835>; else goto <D.30836>;
      <D.30835>:
      mono_get_vtable_var (cfg);
      goto <D.30837>;
      <D.30836>:
      D.30842 = cfg->args;
      D.30843 = *D.30842;
      D.30842 = cfg->args;
      D.30843 = *D.30842;
      D.30844 = D.30843->flags;
      D.30845 = D.30844 | 4;
      D.30843->flags = D.30845;
      <D.30837>:
      <D.30834>:
      <D.30832>:
      if (is_virtual_call != 0) goto <D.30846>; else goto <D.30847>;
      <D.30846>:
      {
        struct MonoInst * arg_ins;

        D.30241 = cfg->mempool;
        arg_ins = mono_mempool_alloc (D.30241, 80);
        arg_ins->data.op[1].const_val = 0;
        D.30848 = arg_ins->data.op[1].const_val;
        arg_ins->data.op[0].const_val = D.30848;
        arg_ins->prev = 0B;
        D.30849 = arg_ins->prev;
        arg_ins->next = D.30849;
        arg_ins->opcode = 424;
        arg_ins->flags = 0;
        arg_ins->type = 0;
        arg_ins->dreg = -1;
        arg_ins->sreg3 = -1;
        D.30850 = arg_ins->sreg3;
        arg_ins->sreg2 = D.30850;
        D.30851 = arg_ins->sreg2;
        arg_ins->sreg1 = D.30851;
        D.30461 = cfg->ip;
        arg_ins->cil_code = D.30461;
        D.30852 = cfg->arg_types;
        D.30853 = *D.30852;
        D.30854 = mono_type_to_regmove (cfg, D.30853);
        D.30855 = (short unsigned int) D.30854;
        arg_ins->opcode = D.30855;
        D.30852 = cfg->arg_types;
        D.30853 = *D.30852;
        type_to_eval_stack_type (cfg, D.30853, arg_ins);
        D.30842 = cfg->args;
        D.30843 = *D.30842;
        D.30856 = D.30843->klass;
        arg_ins->klass = D.30856;
        D.30842 = cfg->args;
        D.30843 = *D.30842;
        D.30857 = D.30843->dreg;
        arg_ins->sreg1 = D.30857;
        D.30858 = arg_ins->type;
        D.30859 = (<unnamed type>) D.30858;
        D.30860 = alloc_dreg (cfg, D.30859);
        D.30861 = (int) D.30860;
        arg_ins->dreg = D.30861;
        D.30862 = arg_ins->opcode;
        if (D.30862 == 427) goto <D.30863>; else goto <D.30864>;
        <D.30863>:
        D.30852 = cfg->arg_types;
        D.30853 = *D.30852;
        D.30865 = mono_class_from_mono_type (D.30853);
        arg_ins->klass = D.30865;
        <D.30864>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.30866>; else goto <D.30867>;
        <D.30866>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = arg_ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        arg_ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = arg_ins;
        goto <D.30868>;
        <D.30867>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = arg_ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.30868>:
        D.30670 = cfg->flags;
        D.30869 = D.30670 | 128;
        cfg->flags = D.30869;
        D.30229 = BIT_FIELD_REF <*cfg, 64, 5632>;
        D.30870 = D.30229 & 144115188075855872;
        if (D.30870 != 0) goto <D.30871>; else goto <D.30872>;
        <D.30871>:
        D.30229 = BIT_FIELD_REF <*cfg, 64, 5632>;
        D.30870 = D.30229 & 144115188075855872;
        if (D.30870 != 0) goto <D.30873>; else goto <D.30874>;
        <D.30873>:
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.30875 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.30875;
          inst->prev = 0B;
          D.30876 = inst->prev;
          inst->next = D.30876;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.30877 = inst->sreg3;
          inst->sreg2 = D.30877;
          D.30878 = inst->sreg2;
          inst->sreg1 = D.30878;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          inst->dreg = -1;
          D.30879 = arg_ins->dreg;
          inst->sreg1 = D.30879;
          inst->data.op[1].const_val = 0;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.30880>; else goto <D.30881>;
          <D.30880>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.30882>;
          <D.30881>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.30882>:
        }
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.30883 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.30883;
          inst->prev = 0B;
          D.30884 = inst->prev;
          inst->next = D.30884;
          inst->opcode = 451;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.30885 = inst->sreg3;
          inst->sreg2 = D.30885;
          D.30886 = inst->sreg2;
          inst->sreg1 = D.30886;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          inst->data.op[1].p = "NullReferenceException";
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.30887>; else goto <D.30888>;
          <D.30887>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.30889>;
          <D.30888>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.30889>:
        }
        goto <D.30890>;
        <D.30874>:
        <D.30890>:
        goto <D.30891>;
        <D.30872>:
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.30892 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.30892;
          inst->prev = 0B;
          D.30893 = inst->prev;
          inst->next = D.30893;
          inst->opcode = 340;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.30894 = inst->sreg3;
          inst->sreg2 = D.30894;
          D.30895 = inst->sreg2;
          inst->sreg1 = D.30895;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          inst->dreg = -1;
          D.30879 = arg_ins->dreg;
          inst->sreg1 = D.30879;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.30896>; else goto <D.30897>;
          <D.30896>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.30898>;
          <D.30897>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.30898>:
        }
        <D.30891>:
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.30899 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.30899;
          inst->prev = 0B;
          D.30900 = inst->prev;
          inst->next = D.30900;
          inst->opcode = 799;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.30901 = inst->sreg3;
          inst->sreg2 = D.30901;
          D.30902 = inst->sreg2;
          inst->sreg1 = D.30902;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          inst->dreg = -1;
          D.30879 = arg_ins->dreg;
          inst->sreg1 = D.30879;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.30903>; else goto <D.30904>;
          <D.30903>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.30905>;
          <D.30904>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.30905>:
        }
      }
      <D.30847>:
      D.30906 = dont_verify == 0;
      skip_dead_blocks = (gboolean) D.30906;
      if (skip_dead_blocks != 0) goto <D.30907>; else goto <D.30908>;
      <D.30907>:
      bb = mono_basic_block_split (method, &error);
      original_bb = bb;
      D.30909 = mono_error_ok (&error);
      if (D.30909 == 0) goto <D.30910>; else goto <D.30911>;
      <D.30910>:
      mono_error_cleanup (&error);
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.30912>; else goto <D.30913>;
      <D.30912>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.30914>; else goto <D.30915>;
      <D.30914>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.30915>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.30913>:
      D.30916 = mini_get_debug_options ();
      D.30917 = D.30916->break_on_unverified;
      if (D.30917 != 0) goto <D.30918>; else goto unverified;
      <D.30918>:
      raise (5);
      <D.30911>:
      D.30919 = bb == 0B;
      D.30920 = (long int) D.30919;
      D.30921 = __builtin_expect (D.30920, 0);
      if (D.30921 != 0) goto <D.30922>; else goto <D.30923>;
      <D.30922>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7115, "bb");
      <D.30923>:
      <D.30908>:
      D.30241 = cfg->mempool;
      D.30924 = header->max_stack;
      D.30925 = (int) D.30924;
      D.30926 = D.30925 + 1;
      D.30927 = (long unsigned int) D.30926;
      D.30928 = (unsigned int) D.30927;
      D.30929 = D.30928 * 8;
      sp = mono_mempool_alloc0 (D.30241, D.30929);
      stack_start = sp;
      ins_flag = 0;
      start_new_bblock = 0;
      bblock.64 = bblock;
      cfg->cbb = bblock.64;
      goto <D.27389>;
      <D.28167>:
      D.30211 = cfg->method;
      if (D.30211 == method) goto <D.30930>; else goto <D.30931>;
      <D.30930>:
      ip.69 = (long int) ip;
      D.30388 = header->code;
      D.30933 = (long int) D.30388;
      D.30934 = ip.69 - D.30933;
      D.30935 = (unsigned int) D.30934;
      cfg->real_offset = D.30935;
      goto <D.30936>;
      <D.30931>:
      cfg->real_offset = inline_offset;
      <D.30936>:
      cfg->ip = ip;
      context_used = 0;
      if (start_new_bblock != 0) goto <D.30937>; else goto <D.30938>;
      <D.30937>:
      bblock.64 = bblock;
      ip.69 = (long int) ip;
      bblock.64 = bblock;
      D.30565 = bblock.64->cil_code;
      D.30568 = (long int) D.30565;
      D.30939 = ip.69 - D.30568;
      D.30940 = (int) D.30939;
      bblock.64->cil_length = D.30940;
      if (start_new_bblock == 2) goto <D.30941>; else goto <D.30942>;
      <D.30941>:
      D.30437 = tblock->cil_code;
      D.30943 = D.30437 != ip;
      D.30944 = (long int) D.30943;
      D.30945 = __builtin_expect (D.30944, 0);
      if (D.30945 != 0) goto <D.30946>; else goto <D.30947>;
      <D.30946>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7136, "ip == tblock->cil_code");
      <D.30947>:
      goto <D.30948>;
      <D.30942>:
      D.30372 = cfg->cil_offset_to_bb;
      ip.69 = (long int) ip;
      D.30377 = cfg->cil_start;
      D.30378 = (long int) D.30377;
      D.30949 = ip.69 - D.30378;
      D.30950 = (long unsigned int) D.30949;
      D.30951 = D.30950 * 8;
      D.30952 = D.30372 + D.30951;
      tblock = *D.30952;
      if (tblock == 0B) goto <D.30953>; else goto <D.30954>;
      <D.30953>:
      if (ip >= end) goto <D.30955>; else goto <D.30957>;
      <D.30957>:
      D.30388 = header->code;
      if (D.30388 > ip) goto <D.30955>; else goto <D.30956>;
      <D.30955>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.30958>; else goto <D.30959>;
      <D.30958>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.30960>; else goto <D.30961>;
      <D.30960>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.30961>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.30959>:
      D.30962 = mini_get_debug_options ();
      D.30963 = D.30962->break_on_unverified;
      if (D.30963 != 0) goto <D.30964>; else goto unverified;
      <D.30964>:
      raise (5);
      <D.30956>:
      D.30241 = cfg->mempool;
      tblock = mono_mempool_alloc0 (D.30241, 296);
      D.30349 = cfg->num_bblocks;
      D.30965 = D.30349;
      D.30966 = D.30965 + 1;
      cfg->num_bblocks = D.30966;
      D.30967 = (int) D.30965;
      tblock->block_num = D.30967;
      tblock->cil_code = ip;
      D.30437 = tblock->cil_code;
      if (D.30437 != 0B) goto <D.30968>; else goto <D.30969>;
      <D.30968>:
      D.30372 = cfg->cil_offset_to_bb;
      D.30437 = tblock->cil_code;
      D.30440 = (long int) D.30437;
      D.30377 = cfg->cil_start;
      D.30378 = (long int) D.30377;
      D.30441 = D.30440 - D.30378;
      D.30442 = (long unsigned int) D.30441;
      D.30443 = D.30442 * 8;
      D.30444 = D.30372 + D.30443;
      *D.30444 = tblock;
      <D.30969>:
      D.30408 = cfg->real_offset;
      tblock->real_offset = D.30408;
      <D.30954>:
      <D.30948>:
      bblock.64 = bblock;
      bblock.64->next_bb = tblock;
      bblock = tblock;
      bblock.64 = bblock;
      cfg->cbb = bblock.64;
      start_new_bblock = 0;
      i = 0;
      goto <D.27382>;
      <D.27381>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 3) goto <D.30970>; else goto <D.30971>;
      <D.30970>:
      bblock.64 = bblock;
      D.30972 = bblock.64->in_stack;
      D.30370 = (long unsigned int) i;
      D.30973 = D.30370 * 8;
      D.30974 = D.30972 + D.30973;
      D.30975 = *D.30974;
      D.30976 = D.30975->data.op[0].const_val;
      D.30977 = (int) D.30976;
      printf ("loading %d from temp %d\n", i, D.30977);
      <D.30971>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.30978 = cfg->varinfo;
      bblock.64 = bblock;
      D.30972 = bblock.64->in_stack;
      D.30370 = (long unsigned int) i;
      D.30973 = D.30370 * 8;
      D.30974 = D.30972 + D.30973;
      D.30975 = *D.30974;
      D.30976 = D.30975->data.op[0].const_val;
      D.30979 = (long unsigned int) D.30976;
      D.30980 = D.30979 * 8;
      D.30981 = D.30978 + D.30980;
      D.30982 = *D.30981;
      D.30983 = D.30982->data.op[1].vtype;
      D.30984 = mono_type_to_regmove (cfg, D.30983);
      D.30985 = (short unsigned int) D.30984;
      ins->opcode = D.30985;
      D.30978 = cfg->varinfo;
      bblock.64 = bblock;
      D.30972 = bblock.64->in_stack;
      D.30370 = (long unsigned int) i;
      D.30973 = D.30370 * 8;
      D.30974 = D.30972 + D.30973;
      D.30975 = *D.30974;
      D.30976 = D.30975->data.op[0].const_val;
      D.30979 = (long unsigned int) D.30976;
      D.30980 = D.30979 * 8;
      D.30981 = D.30978 + D.30980;
      D.30982 = *D.30981;
      D.30983 = D.30982->data.op[1].vtype;
      type_to_eval_stack_type (cfg, D.30983, ins);
      D.30978 = cfg->varinfo;
      bblock.64 = bblock;
      D.30972 = bblock.64->in_stack;
      D.30370 = (long unsigned int) i;
      D.30973 = D.30370 * 8;
      D.30974 = D.30972 + D.30973;
      D.30975 = *D.30974;
      D.30976 = D.30975->data.op[0].const_val;
      D.30979 = (long unsigned int) D.30976;
      D.30980 = D.30979 * 8;
      D.30981 = D.30978 + D.30980;
      D.30982 = *D.30981;
      D.30986 = D.30982->klass;
      ins->klass = D.30986;
      D.30978 = cfg->varinfo;
      bblock.64 = bblock;
      D.30972 = bblock.64->in_stack;
      D.30370 = (long unsigned int) i;
      D.30973 = D.30370 * 8;
      D.30974 = D.30972 + D.30973;
      D.30975 = *D.30974;
      D.30976 = D.30975->data.op[0].const_val;
      D.30979 = (long unsigned int) D.30976;
      D.30980 = D.30979 * 8;
      D.30981 = D.30978 + D.30980;
      D.30982 = *D.30981;
      D.30987 = D.30982->dreg;
      ins->sreg1 = D.30987;
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.30990 = alloc_dreg (cfg, D.30989);
      D.30991 = (int) D.30990;
      ins->dreg = D.30991;
      D.30992 = ins->opcode;
      if (D.30992 == 427) goto <D.30993>; else goto <D.30994>;
      <D.30993>:
      D.30978 = cfg->varinfo;
      bblock.64 = bblock;
      D.30972 = bblock.64->in_stack;
      D.30370 = (long unsigned int) i;
      D.30973 = D.30370 * 8;
      D.30974 = D.30972 + D.30973;
      D.30975 = *D.30974;
      D.30976 = D.30975->data.op[0].const_val;
      D.30979 = (long unsigned int) D.30976;
      D.30980 = D.30979 * 8;
      D.30981 = D.30978 + D.30980;
      D.30982 = *D.30981;
      D.30983 = D.30982->data.op[1].vtype;
      D.30995 = mono_class_from_mono_type (D.30983);
      ins->klass = D.30995;
      <D.30994>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.30996>; else goto <D.30997>;
      <D.30996>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.30998>;
      <D.30997>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.30998>:
      sp.70 = sp;
      sp = sp.70 + 8;
      *sp.70 = ins;
      i = i + 1;
      <D.27382>:
      bblock.64 = bblock;
      D.31000 = bblock.64->in_scount;
      D.31001 = (int) D.31000;
      if (D.31001 > i) goto <D.27381>; else goto <D.27383>;
      <D.27383>:
      if (class_inits != 0B) goto <D.31002>; else goto <D.31003>;
      <D.31002>:
      monoeg_g_slist_free (class_inits);
      <D.31003>:
      class_inits = 0B;
      goto <D.31004>;
      <D.30938>:
      D.30372 = cfg->cil_offset_to_bb;
      ip.69 = (long int) ip;
      D.30377 = cfg->cil_start;
      D.30378 = (long int) D.30377;
      D.30949 = ip.69 - D.30378;
      D.30950 = (long unsigned int) D.30949;
      D.30951 = D.30950 * 8;
      D.30952 = D.30372 + D.30951;
      tblock = *D.30952;
      if (tblock != 0B) goto <D.31005>; else goto <D.31006>;
      <D.31005>:
      bblock.64 = bblock;
      if (tblock != bblock.64) goto <D.31007>; else goto <D.31008>;
      <D.31007>:
      bblock.64 = bblock;
      link_bblock (cfg, bblock.64, tblock);
      if (sp != stack_start) goto <D.31009>; else goto <D.31010>;
      <D.31009>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.31015 = (int) D.31014;
      handle_stack_args (cfg, stack_start, D.31015);
      sp = stack_start;
      D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.31016 = D.30634 & 262144;
      if (D.31016 != 0) goto <D.31017>; else goto <D.31018>;
      <D.31017>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31019>; else goto <D.31020>;
      <D.31019>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31021>; else goto <D.31022>;
      <D.31021>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31022>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31020>:
      D.31023 = mini_get_debug_options ();
      D.31024 = D.31023->break_on_unverified;
      if (D.31024 != 0) goto <D.31025>; else goto unverified;
      <D.31025>:
      raise (5);
      <D.31018>:
      <D.31010>:
      bblock.64 = bblock;
      bblock.64->next_bb = tblock;
      bblock = tblock;
      bblock.64 = bblock;
      cfg->cbb = bblock.64;
      i = 0;
      goto <D.27385>;
      <D.27384>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 3) goto <D.31026>; else goto <D.31027>;
      <D.31026>:
      bblock.64 = bblock;
      D.30972 = bblock.64->in_stack;
      D.30370 = (long unsigned int) i;
      D.30973 = D.30370 * 8;
      D.30974 = D.30972 + D.30973;
      D.30975 = *D.30974;
      D.30976 = D.30975->data.op[0].const_val;
      D.30977 = (int) D.30976;
      printf ("loading %d from temp %d\n", i, D.30977);
      <D.31027>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.30978 = cfg->varinfo;
      bblock.64 = bblock;
      D.30972 = bblock.64->in_stack;
      D.30370 = (long unsigned int) i;
      D.30973 = D.30370 * 8;
      D.30974 = D.30972 + D.30973;
      D.30975 = *D.30974;
      D.30976 = D.30975->data.op[0].const_val;
      D.30979 = (long unsigned int) D.30976;
      D.30980 = D.30979 * 8;
      D.30981 = D.30978 + D.30980;
      D.30982 = *D.30981;
      D.30983 = D.30982->data.op[1].vtype;
      D.31028 = mono_type_to_regmove (cfg, D.30983);
      D.31029 = (short unsigned int) D.31028;
      ins->opcode = D.31029;
      D.30978 = cfg->varinfo;
      bblock.64 = bblock;
      D.30972 = bblock.64->in_stack;
      D.30370 = (long unsigned int) i;
      D.30973 = D.30370 * 8;
      D.30974 = D.30972 + D.30973;
      D.30975 = *D.30974;
      D.30976 = D.30975->data.op[0].const_val;
      D.30979 = (long unsigned int) D.30976;
      D.30980 = D.30979 * 8;
      D.30981 = D.30978 + D.30980;
      D.30982 = *D.30981;
      D.30983 = D.30982->data.op[1].vtype;
      type_to_eval_stack_type (cfg, D.30983, ins);
      D.30978 = cfg->varinfo;
      bblock.64 = bblock;
      D.30972 = bblock.64->in_stack;
      D.30370 = (long unsigned int) i;
      D.30973 = D.30370 * 8;
      D.30974 = D.30972 + D.30973;
      D.30975 = *D.30974;
      D.30976 = D.30975->data.op[0].const_val;
      D.30979 = (long unsigned int) D.30976;
      D.30980 = D.30979 * 8;
      D.30981 = D.30978 + D.30980;
      D.30982 = *D.30981;
      D.30986 = D.30982->klass;
      ins->klass = D.30986;
      D.30978 = cfg->varinfo;
      bblock.64 = bblock;
      D.30972 = bblock.64->in_stack;
      D.30370 = (long unsigned int) i;
      D.30973 = D.30370 * 8;
      D.30974 = D.30972 + D.30973;
      D.30975 = *D.30974;
      D.30976 = D.30975->data.op[0].const_val;
      D.30979 = (long unsigned int) D.30976;
      D.30980 = D.30979 * 8;
      D.30981 = D.30978 + D.30980;
      D.30982 = *D.30981;
      D.30987 = D.30982->dreg;
      ins->sreg1 = D.30987;
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.31030 = alloc_dreg (cfg, D.30989);
      D.31031 = (int) D.31030;
      ins->dreg = D.31031;
      D.30992 = ins->opcode;
      if (D.30992 == 427) goto <D.31032>; else goto <D.31033>;
      <D.31032>:
      D.30978 = cfg->varinfo;
      bblock.64 = bblock;
      D.30972 = bblock.64->in_stack;
      D.30370 = (long unsigned int) i;
      D.30973 = D.30370 * 8;
      D.30974 = D.30972 + D.30973;
      D.30975 = *D.30974;
      D.30976 = D.30975->data.op[0].const_val;
      D.30979 = (long unsigned int) D.30976;
      D.30980 = D.30979 * 8;
      D.30981 = D.30978 + D.30980;
      D.30982 = *D.30981;
      D.30983 = D.30982->data.op[1].vtype;
      D.31034 = mono_class_from_mono_type (D.30983);
      ins->klass = D.31034;
      <D.31033>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.31035>; else goto <D.31036>;
      <D.31035>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.31037>;
      <D.31036>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.31037>:
      sp.73 = sp;
      sp = sp.73 + 8;
      *sp.73 = ins;
      i = i + 1;
      <D.27385>:
      bblock.64 = bblock;
      D.31000 = bblock.64->in_scount;
      D.31001 = (int) D.31000;
      if (D.31001 > i) goto <D.27384>; else goto <D.27386>;
      <D.27386>:
      monoeg_g_slist_free (class_inits);
      class_inits = 0B;
      <D.31008>:
      <D.31006>:
      <D.31004>:
      if (skip_dead_blocks != 0) goto <D.31039>; else goto <D.31040>;
      <D.31039>:
      {
        int ip_offset;

        ip.69 = (long int) ip;
        D.30388 = header->code;
        D.30933 = (long int) D.30388;
        D.30934 = ip.69 - D.30933;
        ip_offset = (int) D.30934;
        D.31041 = bb->end;
        if (D.31041 == ip_offset) goto <D.31042>; else goto <D.31043>;
        <D.31042>:
        bb = bb->next;
        <D.31043>:
        D.31044 = BIT_FIELD_REF <*bb, 64, 384>;
        D.31045 = D.31044 & 4611686018427387904;
        if (D.31045 != 0) goto <D.31046>; else goto <D.31047>;
        <D.31046>:
        {
          int op_size;

          op_size = mono_opcode_size (ip, end);
          D.31048 = op_size <= 0;
          D.31049 = (long int) D.31048;
          D.31050 = __builtin_expect (D.31049, 0);
          if (D.31050 != 0) goto <D.31051>; else goto <D.31052>;
          <D.31051>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7183, "op_size > 0");
          <D.31052>:
          D.30322 = cfg->verbose_level;
          if (D.30322 > 3) goto <D.31053>; else goto <D.31054>;
          <D.31053>:
          printf ("SKIPPING DEAD OP at %x\n", ip_offset);
          <D.31054>:
          D.31055 = ip_offset + op_size;
          D.31041 = bb->end;
          if (D.31055 == D.31041) goto <D.31056>; else goto <D.31057>;
          <D.31056>:
          D.30241 = cfg->mempool;
          ins = mono_mempool_alloc (D.30241, 80);
          ins->data.op[1].const_val = 0;
          D.30457 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.30457;
          ins->prev = 0B;
          D.30458 = ins->prev;
          ins->next = D.30458;
          ins->opcode = 316;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.30459 = ins->sreg3;
          ins->sreg2 = D.30459;
          D.30460 = ins->sreg2;
          ins->sreg1 = D.30460;
          D.30461 = cfg->ip;
          ins->cil_code = D.30461;
          bblock.64 = bblock;
          D.30577 = bblock.64->last_ins;
          if (D.30577 != 0B) goto <D.31058>; else goto <D.31059>;
          <D.31058>:
          bblock.64 = bblock;
          D.30577 = bblock.64->last_ins;
          D.30577->next = ins;
          bblock.64 = bblock;
          D.30577 = bblock.64->last_ins;
          ins->prev = D.30577;
          bblock.64 = bblock;
          bblock.64->last_ins = ins;
          goto <D.31060>;
          <D.31059>:
          bblock.64 = bblock;
          bblock.64 = bblock;
          bblock.64->last_ins = ins;
          D.30577 = bblock.64->last_ins;
          bblock.64->code = D.30577;
          <D.31060>:
          start_new_bblock = 1;
          <D.31057>:
          D.31061 = (sizetype) op_size;
          ip = ip + D.31061;
          // predicted unlikely by continue predictor.
          goto <D.27389>;
        }
        <D.31047>:
      }
      <D.31040>:
      if (seq_points != 0) goto <D.31064>; else goto <D.31065>;
      <D.31064>:
      if (sp == stack_start) goto <D.31062>; else goto <D.31066>;
      <D.31066>:
      if (sym_seq_points != 0) goto <D.31067>; else goto <D.31063>;
      <D.31067>:
      ip.69 = (long int) ip;
      D.30388 = header->code;
      D.30933 = (long int) D.30388;
      D.30934 = ip.69 - D.30933;
      D.31068 = (long unsigned int) D.30934;
      D.31069 = D.31068 / 64;
      D.31070 = seq_point_locs->data[D.31069];
      ip.69 = (long int) ip;
      D.30388 = header->code;
      D.30933 = (long int) D.30388;
      D.30934 = ip.69 - D.30933;
      D.31071 = (unsigned int) D.30934;
      D.31072 = D.31071 & 63;
      D.31073 = D.31070 >> D.31072;
      D.31074 = D.31073 & 1;
      if (D.31074 != 0) goto <D.31062>; else goto <D.31063>;
      <D.31062>:
      {
        gboolean intr_loc;

        D.30388 = header->code;
        if (D.30388 == ip) goto <D.31076>; else goto <D.31079>;
        <D.31079>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 == 0B) goto <D.31080>; else goto <D.31077>;
        <D.31080>:
        D.31081 = cfg->header;
        D.31082 = BIT_FIELD_REF <*D.31081, 64, 64>;
        D.31083 = D.31082 & 65534;
        if (D.31083 != 0) goto <D.31076>; else goto <D.31077>;
        <D.31076>:
        iftmp.74 = 1;
        goto <D.31078>;
        <D.31077>:
        iftmp.74 = 0;
        <D.31078>:
        intr_loc = iftmp.74;
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 341;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        ip.69 = (long int) ip;
        D.30388 = header->code;
        D.30933 = (long int) D.30388;
        D.30934 = ip.69 - D.30933;
        ins->data.op[1].const_val = D.30934;
        D.31084 = intr_loc != 0;
        D.31085 = (unsigned char) D.31084;
        ins->flags = D.31085;
        if (sp != stack_start) goto <D.31086>; else goto <D.31087>;
        <D.31086>:
        D.31088 = ins->flags;
        D.31089 = D.31088 | 4;
        ins->flags = D.31089;
        <D.31087>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.31090>; else goto <D.31091>;
        <D.31090>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.31092>;
        <D.31091>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.31092>:
        if (sym_seq_points != 0) goto <D.31093>; else goto <D.31094>;
        <D.31093>:
        ip.69 = (long int) ip;
        D.30388 = header->code;
        D.30933 = (long int) D.30388;
        D.30934 = ip.69 - D.30933;
        D.31068 = (long unsigned int) D.30934;
        D.31095 = D.31068 / 64;
        D.31096 = seq_point_set_locs->data[D.31095];
        ip.69 = (long int) ip;
        D.30388 = header->code;
        D.30933 = (long int) D.30388;
        D.30934 = ip.69 - D.30933;
        D.31071 = (unsigned int) D.30934;
        D.31072 = D.31071 & 63;
        D.31097 = 1 << D.31072;
        D.31098 = D.31096 | D.31097;
        seq_point_set_locs->data[D.31095] = D.31098;
        <D.31094>:
      }
      <D.31063>:
      <D.31065>:
      bblock.64 = bblock;
      D.30408 = cfg->real_offset;
      bblock.64->real_offset = D.30408;
      D.30211 = cfg->method;
      if (D.30211 == method) goto <D.31099>; else goto <D.31100>;
      <D.31099>:
      D.31101 = cfg->coverage_info;
      if (D.31101 != 0B) goto <D.31102>; else goto <D.31103>;
      <D.31102>:
      {
        guint32 cil_offset;

        ip.69 = (long int) ip;
        D.30388 = header->code;
        D.30933 = (long int) D.30388;
        D.30934 = ip.69 - D.30933;
        cil_offset = (guint32) D.30934;
        D.31101 = cfg->coverage_info;
        D.31101->data[cil_offset].cil_code = ip;
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 363;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        D.31101 = cfg->coverage_info;
        D.31104 = &D.31101->data[cil_offset].count;
        ins->data.op[0].p = D.31104;
        ins->type = 3;
        D.31105 = alloc_dreg (cfg, 3);
        D.31106 = (int) D.31105;
        ins->dreg = D.31106;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.31107>; else goto <D.31108>;
        <D.31107>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.31109>;
        <D.31108>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.31109>:
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.31110 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.31110;
          inst->prev = 0B;
          D.31111 = inst->prev;
          inst->next = D.31111;
          inst->opcode = 381;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.31112 = inst->sreg3;
          inst->sreg2 = D.31112;
          D.31113 = inst->sreg2;
          inst->sreg1 = D.31113;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          D.30654 = ins->dreg;
          inst->dreg = D.30654;
          inst->data.op[0].const_val = 0;
          inst->data.op[1].const_val = 1;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.31114>; else goto <D.31115>;
          <D.31114>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.31116>;
          <D.31115>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.31116>:
        }
      }
      <D.31103>:
      <D.31100>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 3) goto <D.31117>; else goto <D.31118>;
      <D.31117>:
      bblock.64 = bblock;
      D.31119 = bblock.64->block_num;
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.31015 = (int) D.31014;
      D.31120 = mono_disasm_code_one (0B, method, ip, 0B);
      printf ("converting (in B%d: stack: %d) %s", D.31119, D.31015, D.31120);
      <D.31118>:
      D.31121 = *ip;
      D.31122 = (int) D.31121;
      switch (D.31122) <default: <D.28166>, case 0: <D.27393>, case 1: <D.27395>, case 2: <D.27396>, case 3: <D.27397>, case 4: <D.27398>, case 5: <D.27399>, case 6: <D.27400>, case 7: <D.27401>, case 8: <D.27402>, case 9: <D.27403>, case 10: <D.27404>, case 11: <D.27405>, case 12: <D.27406>, case 13: <D.27407>, case 14: <D.27408>, case 15: <D.27409>, case 16: <D.27412>, case 17: <D.27413>, case 18: <D.27414>, case 19: <D.27418>, case 20: <D.27419>, case 21: <D.27420>, case 22: <D.27421>, case 23: <D.27422>, case 24: <D.27423>, case 25: <D.27424>, case 26: <D.27425>, case 27: <D.27426>, case 28: <D.27427>, case 29: <D.27428>, case 30: <D.27429>, case 31: <D.27430>, case 32: <D.27431>, case 33: <D.27432>, case 34: <D.27433>, case 35: <D.27439>, case 37: <D.27445>, case 38: <D.27448>, case 39: <D.27449>, case 40: <D.27463>, case 41: <D.27462>, case 42: <D.27544>, case 43: <D.27550>, case 44: <D.27563>, case 45: <D.27564>, case 46: <D.27551>, case 47: <D.27552>, case 48: <D.27553>, case 49: <D.27554>, case 50: <D.27555>, case 51: <D.27556>, case 52: <D.27557>, case 53: <D.27558>, case 54: <D.27559>, case 55: <D.27560>, case 56: <D.27562>, case 57: <D.27565>, case 58: <D.27566>, case 59: <D.27571>, case 60: <D.27572>, case 61: <D.27573>, case 62: <D.27574>, case 63: <D.27575>, case 64: <D.27576>, case 65: <D.27577>, case 66: <D.27578>, case 67: <D.27579>, case 68: <D.27580>, case 69: <D.27582>, case 70: <D.27611>, case 71: <D.27612>, case 72: <D.27613>, case 73: <D.27614>, case 74: <D.27615>, case 75: <D.27616>, case 76: <D.27617>, case 77: <D.27618>, case 78: <D.27619>, case 79: <D.27620>, case 80: <D.27621>, case 81: <D.27628>, case 82: <D.27629>, case 83: <D.27630>, case 84: <D.27631>, case 85: <D.27632>, case 86: <D.27633>, case 87: <D.27634>, case 88: <D.27638>, case 89: <D.27639>, case 90: <D.27636>, case 91: <D.27640>, case 92: <D.27641>, case 93: <D.27642>, case 94: <D.27643>, case 95: <D.27644>, case 96: <D.27645>, case 97: <D.27646>, case 98: <D.27647>, case 99: <D.27648>, case 100: <D.27649>, case 101: <D.27653>, case 102: <D.27654>, case 103: <D.27655>, case 104: <D.27656>, case 105: <D.27657>, case 106: <D.27661>, case 107: <D.27658>, case 108: <D.27659>, case 109: <D.27660>, case 110: <D.27662>, case 111: <D.27464>, case 112: <D.27697>, case 113: <D.27701>, case 114: <D.27711>, case 115: <D.27716>, case 116: <D.27740>, case 117: <D.27746>, case 118: <D.27665>, case 119: <D.28164>, case 120: <D.28165>, case 121: <D.27773>, case 122: <D.27994>, case 123: <D.27777>, case 124: <D.27778>, case 125: <D.27779>, case 126: <D.27780>, case 127: <D.27781>, case 128: <D.27782>, case 129: <D.27879>, case 130: <D.27675>, case 131: <D.27676>, case 132: <D.27677>, case 133: <D.27678>, case 134: <D.27679>, case 135: <D.27680>, case 136: <D.27681>, case 137: <D.27682>, case 138: <D.27683>, case 139: <D.27684>, case 140: <D.27758>, case 141: <D.27880>, case 142: <D.27894>, case 143: <D.27895>, case 144: <D.27898>, case 145: <D.27899>, case 146: <D.27900>, case 147: <D.27901>, case 148: <D.27902>, case 149: <D.27903>, case 150: <D.27904>, case 151: <D.27905>, case 152: <D.27906>, case 153: <D.27907>, case 154: <D.27908>, case 155: <D.27938>, case 156: <D.27939>, case 157: <D.27940>, case 158: <D.27941>, case 159: <D.27942>, case 160: <D.27943>, case 161: <D.27944>, case 162: <D.27945>, case 163: <D.27897>, case 164: <D.27946>, case 165: <D.27752>, case 179: <D.27668>, case 180: <D.27672>, case 181: <D.27669>, case 182: <D.27673>, case 183: <D.27667>, case 184: <D.27674>, case 185: <D.27663>, case 186: <D.27664>, case 194: <D.27948>, case 195: <D.27947>, case 198: <D.27959>, case 208: <D.27978>, case 209: <D.27685>, case 210: <D.27686>, case 211: <D.27687>, case 212: <D.27670>, case 213: <D.27671>, case 214: <D.27689>, case 215: <D.27690>, case 216: <D.27691>, case 217: <D.27692>, case 218: <D.27693>, case 219: <D.27694>, case 220: <D.27995>, case 221: <D.27999>, case 222: <D.28000>, case 223: <D.27635>, case 224: <D.27688>, case 240: <D.28021>, case 254: <D.28082>>
      <D.27393>:
      if (seq_points != 0) goto <D.31123>; else goto <D.31124>;
      <D.31123>:
      if (sym_seq_points == 0) goto <D.31125>; else goto <D.31126>;
      <D.31125>:
      if (sp != stack_start) goto <D.31127>; else goto <D.31128>;
      <D.31127>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 341;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      ip.69 = (long int) ip;
      D.30388 = header->code;
      D.30933 = (long int) D.30388;
      D.30934 = ip.69 - D.30933;
      ins->data.op[1].const_val = D.30934;
      ins->flags = 0;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.31129>; else goto <D.31130>;
      <D.31129>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.31131>;
      <D.31130>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.31131>:
      <D.31128>:
      <D.31126>:
      <D.31124>:
      D.30229 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.31132 = D.30229 & 576460752303423488;
      if (D.31132 != 0) goto <D.31133>; else goto <D.31134>;
      <D.31133>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 317;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      goto <D.31135>;
      <D.31134>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 316;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      <D.31135>:
      ip = ip + 1;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      if (D.30577 != 0B) goto <D.31136>; else goto <D.31137>;
      <D.31136>:
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      D.30577->next = ins;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      ins->prev = D.30577;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      goto <D.31138>;
      <D.31137>:
      bblock.64 = bblock;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      D.30577 = bblock.64->last_ins;
      bblock.64->code = D.30577;
      <D.31138>:
      goto <D.27394>;
      <D.27395>:
      D.30211 = cfg->method;
      D.31139 = should_insert_brekpoint (D.30211);
      if (D.31139 != 0) goto <D.31140>; else goto <D.31141>;
      <D.31140>:
      ins = mono_emit_jit_icall (cfg, mono_debugger_agent_user_break, 0B);
      goto <D.31142>;
      <D.31141>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 316;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      <D.31142>:
      ip = ip + 1;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      if (D.30577 != 0B) goto <D.31143>; else goto <D.31144>;
      <D.31143>:
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      D.30577->next = ins;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      ins->prev = D.30577;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      goto <D.31145>;
      <D.31144>:
      bblock.64 = bblock;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      D.30577 = bblock.64->last_ins;
      bblock.64->code = D.30577;
      <D.31145>:
      goto <D.27394>;
      <D.27396>:
      <D.27397>:
      <D.27398>:
      <D.27399>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.30924 = header->max_stack;
      D.31146 = (long int) D.30924;
      if (D.31014 >= D.31146) goto <D.31147>; else goto <D.31148>;
      <D.31147>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31149>; else goto <D.31150>;
      <D.31149>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31151>; else goto <D.31152>;
      <D.31151>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31152>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31150>:
      D.31153 = mini_get_debug_options ();
      D.31154 = D.31153->break_on_unverified;
      if (D.31154 != 0) goto <D.31155>; else goto unverified;
      <D.31155>:
      raise (5);
      <D.31148>:
      D.31121 = *ip;
      D.31122 = (int) D.31121;
      n = D.31122 + -2;
      n.75 = (unsigned int) n;
      if (n.75 >= num_args) goto <D.31157>; else goto <D.31158>;
      <D.31157>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31159>; else goto <D.31160>;
      <D.31159>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31161>; else goto <D.31162>;
      <D.31161>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31162>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31160>:
      D.31163 = mini_get_debug_options ();
      D.31164 = D.31163->break_on_unverified;
      if (D.31164 != 0) goto <D.31165>; else goto unverified;
      <D.31165>:
      raise (5);
      <D.31158>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.30852 = cfg->arg_types;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31168 = D.30852 + D.31167;
      D.31169 = *D.31168;
      D.31170 = mono_type_to_regmove (cfg, D.31169);
      D.31171 = (short unsigned int) D.31170;
      ins->opcode = D.31171;
      D.30852 = cfg->arg_types;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31168 = D.30852 + D.31167;
      D.31169 = *D.31168;
      type_to_eval_stack_type (cfg, D.31169, ins);
      D.30842 = cfg->args;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31172 = D.30842 + D.31167;
      D.31173 = *D.31172;
      D.31174 = D.31173->klass;
      ins->klass = D.31174;
      D.30842 = cfg->args;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31172 = D.30842 + D.31167;
      D.31173 = *D.31172;
      D.31175 = D.31173->dreg;
      ins->sreg1 = D.31175;
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.31176 = alloc_dreg (cfg, D.30989);
      D.31177 = (int) D.31176;
      ins->dreg = D.31177;
      D.30992 = ins->opcode;
      if (D.30992 == 427) goto <D.31178>; else goto <D.31179>;
      <D.31178>:
      D.30852 = cfg->arg_types;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31168 = D.30852 + D.31167;
      D.31169 = *D.31168;
      D.31180 = mono_class_from_mono_type (D.31169);
      ins->klass = D.31180;
      <D.31179>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.31181>; else goto <D.31182>;
      <D.31181>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.31183>;
      <D.31182>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.31183>:
      ip = ip + 1;
      sp.76 = sp;
      sp = sp.76 + 8;
      *sp.76 = ins;
      goto <D.27394>;
      <D.27400>:
      <D.27401>:
      <D.27402>:
      <D.27403>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.30924 = header->max_stack;
      D.31146 = (long int) D.30924;
      if (D.31014 >= D.31146) goto <D.31185>; else goto <D.31186>;
      <D.31185>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31187>; else goto <D.31188>;
      <D.31187>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31189>; else goto <D.31190>;
      <D.31189>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31190>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31188>:
      D.31191 = mini_get_debug_options ();
      D.31192 = D.31191->break_on_unverified;
      if (D.31192 != 0) goto <D.31193>; else goto unverified;
      <D.31193>:
      raise (5);
      <D.31186>:
      D.31121 = *ip;
      D.31122 = (int) D.31121;
      n = D.31122 + -6;
      D.30829 = header->num_locals;
      D.31194 = (unsigned int) D.30829;
      n.75 = (unsigned int) n;
      if (D.31194 <= n.75) goto <D.31195>; else goto <D.31196>;
      <D.31195>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31197>; else goto <D.31198>;
      <D.31197>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31199>; else goto <D.31200>;
      <D.31199>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31200>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31198>:
      D.31201 = mini_get_debug_options ();
      D.31202 = D.31201->break_on_unverified;
      if (D.31202 != 0) goto <D.31203>; else goto unverified;
      <D.31203>:
      raise (5);
      <D.31196>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.30817 = header->locals[n];
      D.31204 = mono_type_to_regmove (cfg, D.30817);
      D.31205 = (short unsigned int) D.31204;
      ins->opcode = D.31205;
      D.30817 = header->locals[n];
      type_to_eval_stack_type (cfg, D.30817, ins);
      D.31206 = cfg->locals;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31207 = D.31206 + D.31167;
      D.31208 = *D.31207;
      D.31209 = D.31208->klass;
      ins->klass = D.31209;
      D.31206 = cfg->locals;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31207 = D.31206 + D.31167;
      D.31208 = *D.31207;
      D.31210 = D.31208->dreg;
      ins->sreg1 = D.31210;
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.31211 = alloc_dreg (cfg, D.30989);
      D.31212 = (int) D.31211;
      ins->dreg = D.31212;
      D.30992 = ins->opcode;
      if (D.30992 == 427) goto <D.31213>; else goto <D.31214>;
      <D.31213>:
      D.30817 = header->locals[n];
      D.31215 = mono_class_from_mono_type (D.30817);
      ins->klass = D.31215;
      <D.31214>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.31216>; else goto <D.31217>;
      <D.31216>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.31218>;
      <D.31217>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.31218>:
      ip = ip + 1;
      sp.77 = sp;
      sp = sp.77 + 8;
      *sp.77 = ins;
      goto <D.27394>;
      <D.27404>:
      <D.27405>:
      <D.27406>:
      <D.27407>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.31220>; else goto <D.31221>;
      <D.31220>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31222>; else goto <D.31223>;
      <D.31222>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31224>; else goto <D.31225>;
      <D.31224>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31225>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31223>:
      D.31226 = mini_get_debug_options ();
      D.31227 = D.31226->break_on_unverified;
      if (D.31227 != 0) goto <D.31228>; else goto unverified;
      <D.31228>:
      raise (5);
      <D.31221>:
      D.31121 = *ip;
      D.31122 = (int) D.31121;
      n = D.31122 + -10;
      D.30829 = header->num_locals;
      D.31194 = (unsigned int) D.30829;
      n.75 = (unsigned int) n;
      if (D.31194 <= n.75) goto <D.31229>; else goto <D.31230>;
      <D.31229>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31231>; else goto <D.31232>;
      <D.31231>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31233>; else goto <D.31234>;
      <D.31233>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31234>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31232>:
      D.31235 = mini_get_debug_options ();
      D.31236 = D.31235->break_on_unverified;
      if (D.31236 != 0) goto <D.31237>; else goto unverified;
      <D.31237>:
      raise (5);
      <D.31230>:
      sp = sp + 18446744073709551608;
      if (dont_verify_stloc == 0) goto <D.31238>; else goto <D.31239>;
      <D.31238>:
      D.30817 = header->locals[n];
      D.31240 = *sp;
      D.31241 = target_type_is_incompatible (cfg, D.30817, D.31240);
      if (D.31241 != 0) goto <D.31242>; else goto <D.31243>;
      <D.31242>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31244>; else goto <D.31245>;
      <D.31244>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31246>; else goto <D.31247>;
      <D.31246>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31247>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31245>:
      D.31248 = mini_get_debug_options ();
      D.31249 = D.31248->break_on_unverified;
      if (D.31249 != 0) goto <D.31250>; else goto unverified;
      <D.31250>:
      raise (5);
      <D.31243>:
      <D.31239>:
      emit_stloc_ir (cfg, sp, header, n);
      ip = ip + 1;
      inline_costs = inline_costs + 1;
      goto <D.27394>;
      <D.27408>:
      D.31251 = ip + 2;
      if (D.31251 > end) goto <D.31252>; else goto <D.31253>;
      <D.31252>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31254>; else goto <D.31255>;
      <D.31254>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31256>; else goto <D.31257>;
      <D.31256>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31257>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31255>:
      D.31258 = mini_get_debug_options ();
      D.31259 = D.31258->break_on_unverified;
      if (D.31259 != 0) goto <D.31260>; else goto unverified;
      <D.31260>:
      raise (5);
      <D.31253>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.30924 = header->max_stack;
      D.31146 = (long int) D.30924;
      if (D.31014 >= D.31146) goto <D.31261>; else goto <D.31262>;
      <D.31261>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31263>; else goto <D.31264>;
      <D.31263>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31265>; else goto <D.31266>;
      <D.31265>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31266>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31264>:
      D.31267 = mini_get_debug_options ();
      D.31268 = D.31267->break_on_unverified;
      if (D.31268 != 0) goto <D.31269>; else goto unverified;
      <D.31269>:
      raise (5);
      <D.31262>:
      D.31270 = ip + 1;
      D.31271 = *D.31270;
      n = (int) D.31271;
      n.75 = (unsigned int) n;
      if (n.75 >= num_args) goto <D.31272>; else goto <D.31273>;
      <D.31272>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31274>; else goto <D.31275>;
      <D.31274>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31276>; else goto <D.31277>;
      <D.31276>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31277>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31275>:
      D.31278 = mini_get_debug_options ();
      D.31279 = D.31278->break_on_unverified;
      if (D.31279 != 0) goto <D.31280>; else goto unverified;
      <D.31280>:
      raise (5);
      <D.31273>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.30852 = cfg->arg_types;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31168 = D.30852 + D.31167;
      D.31169 = *D.31168;
      D.31281 = mono_type_to_regmove (cfg, D.31169);
      D.31282 = (short unsigned int) D.31281;
      ins->opcode = D.31282;
      D.30852 = cfg->arg_types;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31168 = D.30852 + D.31167;
      D.31169 = *D.31168;
      type_to_eval_stack_type (cfg, D.31169, ins);
      D.30842 = cfg->args;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31172 = D.30842 + D.31167;
      D.31173 = *D.31172;
      D.31174 = D.31173->klass;
      ins->klass = D.31174;
      D.30842 = cfg->args;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31172 = D.30842 + D.31167;
      D.31173 = *D.31172;
      D.31175 = D.31173->dreg;
      ins->sreg1 = D.31175;
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.31283 = alloc_dreg (cfg, D.30989);
      D.31284 = (int) D.31283;
      ins->dreg = D.31284;
      D.30992 = ins->opcode;
      if (D.30992 == 427) goto <D.31285>; else goto <D.31286>;
      <D.31285>:
      D.30852 = cfg->arg_types;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31168 = D.30852 + D.31167;
      D.31169 = *D.31168;
      D.31287 = mono_class_from_mono_type (D.31169);
      ins->klass = D.31287;
      <D.31286>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.31288>; else goto <D.31289>;
      <D.31288>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.31290>;
      <D.31289>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.31290>:
      sp.78 = sp;
      sp = sp.78 + 8;
      *sp.78 = ins;
      ip = ip + 2;
      goto <D.27394>;
      <D.27409>:
      D.31251 = ip + 2;
      if (D.31251 > end) goto <D.31292>; else goto <D.31293>;
      <D.31292>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31294>; else goto <D.31295>;
      <D.31294>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31296>; else goto <D.31297>;
      <D.31296>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31297>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31295>:
      D.31298 = mini_get_debug_options ();
      D.31299 = D.31298->break_on_unverified;
      if (D.31299 != 0) goto <D.31300>; else goto unverified;
      <D.31300>:
      raise (5);
      <D.31293>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.30924 = header->max_stack;
      D.31146 = (long int) D.30924;
      if (D.31014 >= D.31146) goto <D.31301>; else goto <D.31302>;
      <D.31301>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31303>; else goto <D.31304>;
      <D.31303>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31305>; else goto <D.31306>;
      <D.31305>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31306>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31304>:
      D.31307 = mini_get_debug_options ();
      D.31308 = D.31307->break_on_unverified;
      if (D.31308 != 0) goto <D.31309>; else goto unverified;
      <D.31309>:
      raise (5);
      <D.31302>:
      D.31270 = ip + 1;
      D.31271 = *D.31270;
      n = (int) D.31271;
      n.75 = (unsigned int) n;
      if (n.75 >= num_args) goto <D.31310>; else goto <D.31311>;
      <D.31310>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31312>; else goto <D.31313>;
      <D.31312>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31314>; else goto <D.31315>;
      <D.31314>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31315>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31313>:
      D.31316 = mini_get_debug_options ();
      D.31317 = D.31316->break_on_unverified;
      if (D.31317 != 0) goto <D.31318>; else goto unverified;
      <D.31318>:
      raise (5);
      <D.31311>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 314;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31319 = arg_array + D.31167;
      D.31320 = *D.31319;
      ins->data.op[0].p = D.31320;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31319 = arg_array + D.31167;
      D.31320 = *D.31319;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31319 = arg_array + D.31167;
      D.31320 = *D.31319;
      D.31321 = D.31320->flags;
      D.31322 = D.31321 | 16;
      D.31320->flags = D.31322;
      ins->type = 5;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31319 = arg_array + D.31167;
      D.31320 = *D.31319;
      D.31323 = D.31320->klass;
      ins->klass = D.31323;
      D.31324 = alloc_dreg (cfg, 5);
      D.31325 = (int) D.31324;
      ins->dreg = D.31325;
      cfg->has_indirection = 1;
      D.30389 = cfg->gsharedvt;
      D.31326 = D.30389 != 0;
      D.31327 = (long int) D.31326;
      D.31328 = __builtin_expect (D.31327, 0);
      if (D.31328 != 0) goto <D.31329>; else goto <D.31330>;
      <D.31329>:
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31319 = arg_array + D.31167;
      D.31320 = *D.31319;
      D.31331 = D.31320->data.op[1].vtype;
      D.31332 = mini_is_gsharedvt_variable_type (cfg, D.31331);
      if (D.31332 != 0) goto <D.31333>; else goto <D.31334>;
      <D.31333>:
      handle_gsharedvt_ldaddr (cfg);
      <D.31334>:
      <D.31330>:
      if (0 != 0) goto <D.31335>; else goto <D.31336>;
      <D.31335>:
      {
        struct MonoInst * var1;
        struct MonoInst * var2;

        D.31166 = (long unsigned int) n;
        D.31167 = D.31166 * 8;
        D.31319 = arg_array + D.31167;
        D.31320 = *D.31319;
        D.31338 = D.31320->dreg;
        D.31339 = D.31338 + 1;
        D.31340 = (unsigned int) D.31339;
        D.31341 = cfg->vreg_to_inst_len;
        if (D.31340 < D.31341) goto <D.31342>; else goto <D.31343>;
        <D.31342>:
        D.31344 = cfg->vreg_to_inst;
        D.31166 = (long unsigned int) n;
        D.31167 = D.31166 * 8;
        D.31319 = arg_array + D.31167;
        D.31320 = *D.31319;
        D.31338 = D.31320->dreg;
        D.31345 = (sizetype) D.31338;
        D.31346 = D.31345 + 1;
        D.31347 = D.31346 * 8;
        D.31348 = D.31344 + D.31347;
        iftmp.79 = *D.31348;
        goto <D.31349>;
        <D.31343>:
        iftmp.79 = 0B;
        <D.31349>:
        var1 = iftmp.79;
        D.31166 = (long unsigned int) n;
        D.31167 = D.31166 * 8;
        D.31319 = arg_array + D.31167;
        D.31320 = *D.31319;
        D.31338 = D.31320->dreg;
        D.31351 = D.31338 + 2;
        D.31352 = (unsigned int) D.31351;
        D.31341 = cfg->vreg_to_inst_len;
        if (D.31352 < D.31341) goto <D.31353>; else goto <D.31354>;
        <D.31353>:
        D.31344 = cfg->vreg_to_inst;
        D.31166 = (long unsigned int) n;
        D.31167 = D.31166 * 8;
        D.31319 = arg_array + D.31167;
        D.31320 = *D.31319;
        D.31338 = D.31320->dreg;
        D.31345 = (sizetype) D.31338;
        D.31355 = D.31345 + 2;
        D.31356 = D.31355 * 8;
        D.31357 = D.31344 + D.31356;
        iftmp.80 = *D.31357;
        goto <D.31358>;
        <D.31354>:
        iftmp.80 = 0B;
        <D.31358>:
        var2 = iftmp.80;
        D.31359 = var1 == 0B;
        D.31360 = (long int) D.31359;
        D.31361 = __builtin_expect (D.31360, 0);
        if (D.31361 != 0) goto <D.31362>; else goto <D.31363>;
        <D.31362>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7323, "var1");
        <D.31363>:
        D.31364 = var2 == 0B;
        D.31365 = (long int) D.31364;
        D.31366 = __builtin_expect (D.31365, 0);
        if (D.31366 != 0) goto <D.31367>; else goto <D.31368>;
        <D.31367>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7323, "var2");
        <D.31368>:
        D.31369 = var1->flags;
        D.31370 = D.31369 | 16;
        var1->flags = D.31370;
        D.31371 = var2->flags;
        D.31372 = D.31371 | 16;
        var2->flags = D.31372;
      }
      <D.31336>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.31373>; else goto <D.31374>;
      <D.31373>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.31375>;
      <D.31374>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.31375>:
      sp.81 = sp;
      sp = sp.81 + 8;
      *sp.81 = ins;
      ip = ip + 2;
      goto <D.27394>;
      <D.27412>:
      D.31251 = ip + 2;
      if (D.31251 > end) goto <D.31377>; else goto <D.31378>;
      <D.31377>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31379>; else goto <D.31380>;
      <D.31379>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31381>; else goto <D.31382>;
      <D.31381>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31382>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31380>:
      D.31383 = mini_get_debug_options ();
      D.31384 = D.31383->break_on_unverified;
      if (D.31384 != 0) goto <D.31385>; else goto unverified;
      <D.31385>:
      raise (5);
      <D.31378>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.31386>; else goto <D.31387>;
      <D.31386>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31388>; else goto <D.31389>;
      <D.31388>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31390>; else goto <D.31391>;
      <D.31390>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31391>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31389>:
      D.31392 = mini_get_debug_options ();
      D.31393 = D.31392->break_on_unverified;
      if (D.31393 != 0) goto <D.31394>; else goto unverified;
      <D.31394>:
      raise (5);
      <D.31387>:
      sp = sp + 18446744073709551608;
      D.31270 = ip + 1;
      D.31271 = *D.31270;
      n = (int) D.31271;
      n.75 = (unsigned int) n;
      if (n.75 >= num_args) goto <D.31395>; else goto <D.31396>;
      <D.31395>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31397>; else goto <D.31398>;
      <D.31397>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31399>; else goto <D.31400>;
      <D.31399>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31400>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31398>:
      D.31401 = mini_get_debug_options ();
      D.31402 = D.31401->break_on_unverified;
      if (D.31402 != 0) goto <D.31403>; else goto unverified;
      <D.31403>:
      raise (5);
      <D.31396>:
      if (dont_verify_stloc == 0) goto <D.31404>; else goto <D.31405>;
      <D.31404>:
      D.31270 = ip + 1;
      D.31271 = *D.31270;
      D.31406 = (long unsigned int) D.31271;
      D.31407 = D.31406 * 8;
      D.31408 = param_types + D.31407;
      D.31409 = *D.31408;
      D.31240 = *sp;
      D.31410 = target_type_is_incompatible (cfg, D.31409, D.31240);
      if (D.31410 != 0) goto <D.31411>; else goto <D.31412>;
      <D.31411>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31413>; else goto <D.31414>;
      <D.31413>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31415>; else goto <D.31416>;
      <D.31415>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31416>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31414>:
      D.31417 = mini_get_debug_options ();
      D.31418 = D.31417->break_on_unverified;
      if (D.31418 != 0) goto <D.31419>; else goto unverified;
      <D.31419>:
      raise (5);
      <D.31412>:
      <D.31405>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.30852 = cfg->arg_types;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31168 = D.30852 + D.31167;
      D.31169 = *D.31168;
      D.31420 = mono_type_to_regmove (cfg, D.31169);
      D.31421 = (short unsigned int) D.31420;
      ins->opcode = D.31421;
      D.30842 = cfg->args;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31172 = D.30842 + D.31167;
      D.31173 = *D.31172;
      D.31174 = D.31173->klass;
      ins->klass = D.31174;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      D.30842 = cfg->args;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31172 = D.30842 + D.31167;
      D.31173 = *D.31172;
      D.31175 = D.31173->dreg;
      ins->dreg = D.31175;
      D.30992 = ins->opcode;
      if (D.30992 == 427) goto <D.31423>; else goto <D.31424>;
      <D.31423>:
      D.30852 = cfg->arg_types;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31168 = D.30852 + D.31167;
      D.31169 = *D.31168;
      D.31425 = mono_class_from_mono_type (D.31169);
      ins->klass = D.31425;
      <D.31424>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.31426>; else goto <D.31427>;
      <D.31426>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.31428>;
      <D.31427>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.31428>:
      ip = ip + 2;
      goto <D.27394>;
      <D.27413>:
      D.31251 = ip + 2;
      if (D.31251 > end) goto <D.31429>; else goto <D.31430>;
      <D.31429>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31431>; else goto <D.31432>;
      <D.31431>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31433>; else goto <D.31434>;
      <D.31433>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31434>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31432>:
      D.31435 = mini_get_debug_options ();
      D.31436 = D.31435->break_on_unverified;
      if (D.31436 != 0) goto <D.31437>; else goto unverified;
      <D.31437>:
      raise (5);
      <D.31430>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.30924 = header->max_stack;
      D.31146 = (long int) D.30924;
      if (D.31014 >= D.31146) goto <D.31438>; else goto <D.31439>;
      <D.31438>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31440>; else goto <D.31441>;
      <D.31440>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31442>; else goto <D.31443>;
      <D.31442>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31443>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31441>:
      D.31444 = mini_get_debug_options ();
      D.31445 = D.31444->break_on_unverified;
      if (D.31445 != 0) goto <D.31446>; else goto unverified;
      <D.31446>:
      raise (5);
      <D.31439>:
      D.31270 = ip + 1;
      D.31271 = *D.31270;
      n = (int) D.31271;
      D.30829 = header->num_locals;
      D.31194 = (unsigned int) D.30829;
      n.75 = (unsigned int) n;
      if (D.31194 <= n.75) goto <D.31447>; else goto <D.31448>;
      <D.31447>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31449>; else goto <D.31450>;
      <D.31449>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31451>; else goto <D.31452>;
      <D.31451>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31452>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31450>:
      D.31453 = mini_get_debug_options ();
      D.31454 = D.31453->break_on_unverified;
      if (D.31454 != 0) goto <D.31455>; else goto unverified;
      <D.31455>:
      raise (5);
      <D.31448>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.30817 = header->locals[n];
      D.31456 = mono_type_to_regmove (cfg, D.30817);
      D.31457 = (short unsigned int) D.31456;
      ins->opcode = D.31457;
      D.30817 = header->locals[n];
      type_to_eval_stack_type (cfg, D.30817, ins);
      D.31206 = cfg->locals;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31207 = D.31206 + D.31167;
      D.31208 = *D.31207;
      D.31209 = D.31208->klass;
      ins->klass = D.31209;
      D.31206 = cfg->locals;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31207 = D.31206 + D.31167;
      D.31208 = *D.31207;
      D.31210 = D.31208->dreg;
      ins->sreg1 = D.31210;
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.31458 = alloc_dreg (cfg, D.30989);
      D.31459 = (int) D.31458;
      ins->dreg = D.31459;
      D.30992 = ins->opcode;
      if (D.30992 == 427) goto <D.31460>; else goto <D.31461>;
      <D.31460>:
      D.30817 = header->locals[n];
      D.31462 = mono_class_from_mono_type (D.30817);
      ins->klass = D.31462;
      <D.31461>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.31463>; else goto <D.31464>;
      <D.31463>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.31465>;
      <D.31464>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.31465>:
      sp.82 = sp;
      sp = sp.82 + 8;
      *sp.82 = ins;
      ip = ip + 2;
      goto <D.27394>;
      <D.27414>:
      {
        unsigned char * tmp_ip;

        D.31251 = ip + 2;
        if (D.31251 > end) goto <D.31467>; else goto <D.31468>;
        <D.31467>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.31469>; else goto <D.31470>;
        <D.31469>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.31471>; else goto <D.31472>;
        <D.31471>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.31472>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.31470>:
        D.31473 = mini_get_debug_options ();
        D.31474 = D.31473->break_on_unverified;
        if (D.31474 != 0) goto <D.31475>; else goto unverified;
        <D.31475>:
        raise (5);
        <D.31468>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        D.31014 = D.31013 /[ex] 8;
        D.30924 = header->max_stack;
        D.31146 = (long int) D.30924;
        if (D.31014 >= D.31146) goto <D.31476>; else goto <D.31477>;
        <D.31476>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.31478>; else goto <D.31479>;
        <D.31478>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.31480>; else goto <D.31481>;
        <D.31480>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.31481>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.31479>:
        D.31482 = mini_get_debug_options ();
        D.31483 = D.31482->break_on_unverified;
        if (D.31483 != 0) goto <D.31484>; else goto unverified;
        <D.31484>:
        raise (5);
        <D.31477>:
        D.31270 = ip + 1;
        D.31271 = *D.31270;
        D.31485 = (short unsigned int) D.31271;
        D.30829 = header->num_locals;
        if (D.31485 >= D.30829) goto <D.31486>; else goto <D.31487>;
        <D.31486>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.31488>; else goto <D.31489>;
        <D.31488>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.31490>; else goto <D.31491>;
        <D.31490>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.31491>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.31489>:
        D.31492 = mini_get_debug_options ();
        D.31493 = D.31492->break_on_unverified;
        if (D.31493 != 0) goto <D.31494>; else goto unverified;
        <D.31494>:
        raise (5);
        <D.31487>:
        tmp_ip = emit_optimized_ldloca_ir (cfg, ip, end, 1);
        if (tmp_ip != 0B) goto <D.31495>; else goto <D.31496>;
        <D.31495>:
        ip = tmp_ip;
        inline_costs = inline_costs + 1;
        goto <D.27394>;
        <D.31496>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 314;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        D.31206 = cfg->locals;
        D.31270 = ip + 1;
        D.31271 = *D.31270;
        D.31406 = (long unsigned int) D.31271;
        D.31407 = D.31406 * 8;
        D.31497 = D.31206 + D.31407;
        D.31498 = *D.31497;
        ins->data.op[0].p = D.31498;
        D.31206 = cfg->locals;
        D.31270 = ip + 1;
        D.31271 = *D.31270;
        D.31406 = (long unsigned int) D.31271;
        D.31407 = D.31406 * 8;
        D.31497 = D.31206 + D.31407;
        D.31498 = *D.31497;
        D.31206 = cfg->locals;
        D.31270 = ip + 1;
        D.31271 = *D.31270;
        D.31406 = (long unsigned int) D.31271;
        D.31407 = D.31406 * 8;
        D.31497 = D.31206 + D.31407;
        D.31498 = *D.31497;
        D.31499 = D.31498->flags;
        D.31500 = D.31499 | 16;
        D.31498->flags = D.31500;
        ins->type = 5;
        D.31206 = cfg->locals;
        D.31270 = ip + 1;
        D.31271 = *D.31270;
        D.31406 = (long unsigned int) D.31271;
        D.31407 = D.31406 * 8;
        D.31497 = D.31206 + D.31407;
        D.31498 = *D.31497;
        D.31501 = D.31498->klass;
        ins->klass = D.31501;
        D.31502 = alloc_dreg (cfg, 5);
        D.31503 = (int) D.31502;
        ins->dreg = D.31503;
        cfg->has_indirection = 1;
        D.30389 = cfg->gsharedvt;
        D.31326 = D.30389 != 0;
        D.31327 = (long int) D.31326;
        D.31328 = __builtin_expect (D.31327, 0);
        if (D.31328 != 0) goto <D.31504>; else goto <D.31505>;
        <D.31504>:
        D.31206 = cfg->locals;
        D.31270 = ip + 1;
        D.31271 = *D.31270;
        D.31406 = (long unsigned int) D.31271;
        D.31407 = D.31406 * 8;
        D.31497 = D.31206 + D.31407;
        D.31498 = *D.31497;
        D.31506 = D.31498->data.op[1].vtype;
        D.31507 = mini_is_gsharedvt_variable_type (cfg, D.31506);
        if (D.31507 != 0) goto <D.31508>; else goto <D.31509>;
        <D.31508>:
        handle_gsharedvt_ldaddr (cfg);
        <D.31509>:
        <D.31505>:
        if (0 != 0) goto <D.31510>; else goto <D.31511>;
        <D.31510>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.31206 = cfg->locals;
          D.31270 = ip + 1;
          D.31271 = *D.31270;
          D.31406 = (long unsigned int) D.31271;
          D.31407 = D.31406 * 8;
          D.31497 = D.31206 + D.31407;
          D.31498 = *D.31497;
          D.31513 = D.31498->dreg;
          D.31514 = D.31513 + 1;
          D.31515 = (unsigned int) D.31514;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.31515 < D.31341) goto <D.31516>; else goto <D.31517>;
          <D.31516>:
          D.31344 = cfg->vreg_to_inst;
          D.31206 = cfg->locals;
          D.31270 = ip + 1;
          D.31271 = *D.31270;
          D.31406 = (long unsigned int) D.31271;
          D.31407 = D.31406 * 8;
          D.31497 = D.31206 + D.31407;
          D.31498 = *D.31497;
          D.31513 = D.31498->dreg;
          D.31518 = (sizetype) D.31513;
          D.31519 = D.31518 + 1;
          D.31520 = D.31519 * 8;
          D.31521 = D.31344 + D.31520;
          iftmp.83 = *D.31521;
          goto <D.31522>;
          <D.31517>:
          iftmp.83 = 0B;
          <D.31522>:
          var1 = iftmp.83;
          D.31206 = cfg->locals;
          D.31270 = ip + 1;
          D.31271 = *D.31270;
          D.31406 = (long unsigned int) D.31271;
          D.31407 = D.31406 * 8;
          D.31497 = D.31206 + D.31407;
          D.31498 = *D.31497;
          D.31513 = D.31498->dreg;
          D.31524 = D.31513 + 2;
          D.31525 = (unsigned int) D.31524;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.31525 < D.31341) goto <D.31526>; else goto <D.31527>;
          <D.31526>:
          D.31344 = cfg->vreg_to_inst;
          D.31206 = cfg->locals;
          D.31270 = ip + 1;
          D.31271 = *D.31270;
          D.31406 = (long unsigned int) D.31271;
          D.31407 = D.31406 * 8;
          D.31497 = D.31206 + D.31407;
          D.31498 = *D.31497;
          D.31513 = D.31498->dreg;
          D.31518 = (sizetype) D.31513;
          D.31528 = D.31518 + 2;
          D.31529 = D.31528 * 8;
          D.31530 = D.31344 + D.31529;
          iftmp.84 = *D.31530;
          goto <D.31531>;
          <D.31527>:
          iftmp.84 = 0B;
          <D.31531>:
          var2 = iftmp.84;
          D.31532 = var1 == 0B;
          D.31533 = (long int) D.31532;
          D.31534 = __builtin_expect (D.31533, 0);
          if (D.31534 != 0) goto <D.31535>; else goto <D.31536>;
          <D.31535>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7360, "var1");
          <D.31536>:
          D.31537 = var2 == 0B;
          D.31538 = (long int) D.31537;
          D.31539 = __builtin_expect (D.31538, 0);
          if (D.31539 != 0) goto <D.31540>; else goto <D.31541>;
          <D.31540>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7360, "var2");
          <D.31541>:
          D.31542 = var1->flags;
          D.31543 = D.31542 | 16;
          var1->flags = D.31543;
          D.31544 = var2->flags;
          D.31545 = D.31544 | 16;
          var2->flags = D.31545;
        }
        <D.31511>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.31546>; else goto <D.31547>;
        <D.31546>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.31548>;
        <D.31547>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.31548>:
        sp.85 = sp;
        sp = sp.85 + 8;
        *sp.85 = ins;
        ip = ip + 2;
        goto <D.27394>;
      }
      <D.27418>:
      D.31251 = ip + 2;
      if (D.31251 > end) goto <D.31550>; else goto <D.31551>;
      <D.31550>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31552>; else goto <D.31553>;
      <D.31552>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31554>; else goto <D.31555>;
      <D.31554>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31555>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31553>:
      D.31556 = mini_get_debug_options ();
      D.31557 = D.31556->break_on_unverified;
      if (D.31557 != 0) goto <D.31558>; else goto unverified;
      <D.31558>:
      raise (5);
      <D.31551>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.31559>; else goto <D.31560>;
      <D.31559>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31561>; else goto <D.31562>;
      <D.31561>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31563>; else goto <D.31564>;
      <D.31563>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31564>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31562>:
      D.31565 = mini_get_debug_options ();
      D.31566 = D.31565->break_on_unverified;
      if (D.31566 != 0) goto <D.31567>; else goto unverified;
      <D.31567>:
      raise (5);
      <D.31560>:
      sp = sp + 18446744073709551608;
      D.31270 = ip + 1;
      D.31271 = *D.31270;
      D.31485 = (short unsigned int) D.31271;
      D.30829 = header->num_locals;
      if (D.31485 >= D.30829) goto <D.31568>; else goto <D.31569>;
      <D.31568>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31570>; else goto <D.31571>;
      <D.31570>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31572>; else goto <D.31573>;
      <D.31572>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31573>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31571>:
      D.31574 = mini_get_debug_options ();
      D.31575 = D.31574->break_on_unverified;
      if (D.31575 != 0) goto <D.31576>; else goto unverified;
      <D.31576>:
      raise (5);
      <D.31569>:
      if (dont_verify_stloc == 0) goto <D.31577>; else goto <D.31578>;
      <D.31577>:
      D.31270 = ip + 1;
      D.31271 = *D.31270;
      D.31579 = (int) D.31271;
      D.31580 = header->locals[D.31579];
      D.31240 = *sp;
      D.31581 = target_type_is_incompatible (cfg, D.31580, D.31240);
      if (D.31581 != 0) goto <D.31582>; else goto <D.31583>;
      <D.31582>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31584>; else goto <D.31585>;
      <D.31584>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31586>; else goto <D.31587>;
      <D.31586>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31587>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31585>:
      D.31588 = mini_get_debug_options ();
      D.31589 = D.31588->break_on_unverified;
      if (D.31589 != 0) goto <D.31590>; else goto unverified;
      <D.31590>:
      raise (5);
      <D.31583>:
      <D.31578>:
      D.31270 = ip + 1;
      D.31271 = *D.31270;
      D.31579 = (int) D.31271;
      emit_stloc_ir (cfg, sp, header, D.31579);
      ip = ip + 2;
      inline_costs = inline_costs + 1;
      goto <D.27394>;
      <D.27419>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.30924 = header->max_stack;
      D.31146 = (long int) D.30924;
      if (D.31014 >= D.31146) goto <D.31591>; else goto <D.31592>;
      <D.31591>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31593>; else goto <D.31594>;
      <D.31593>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31595>; else goto <D.31596>;
      <D.31595>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31596>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31594>:
      D.31597 = mini_get_debug_options ();
      D.31598 = D.31597->break_on_unverified;
      if (D.31598 != 0) goto <D.31599>; else goto unverified;
      <D.31599>:
      raise (5);
      <D.31592>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 363;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      ins->data.op[0].p = 0B;
      ins->type = 3;
      D.31600 = alloc_dreg (cfg, 3);
      D.31601 = (int) D.31600;
      ins->dreg = D.31601;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.31602>; else goto <D.31603>;
      <D.31602>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.31604>;
      <D.31603>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.31604>:
      ins->type = 6;
      ip = ip + 1;
      sp.86 = sp;
      sp = sp.86 + 8;
      *sp.86 = ins;
      goto <D.27394>;
      <D.27420>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.30924 = header->max_stack;
      D.31146 = (long int) D.30924;
      if (D.31014 >= D.31146) goto <D.31606>; else goto <D.31607>;
      <D.31606>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31608>; else goto <D.31609>;
      <D.31608>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31610>; else goto <D.31611>;
      <D.31610>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31611>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31609>:
      D.31612 = mini_get_debug_options ();
      D.31613 = D.31612->break_on_unverified;
      if (D.31613 != 0) goto <D.31614>; else goto unverified;
      <D.31614>:
      raise (5);
      <D.31607>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 362;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      ins->data.op[0].const_val = -1;
      ins->type = 1;
      D.31615 = alloc_dreg (cfg, 1);
      D.31616 = (int) D.31615;
      ins->dreg = D.31616;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.31617>; else goto <D.31618>;
      <D.31617>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.31619>;
      <D.31618>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.31619>:
      ip = ip + 1;
      sp.87 = sp;
      sp = sp.87 + 8;
      *sp.87 = ins;
      goto <D.27394>;
      <D.27421>:
      <D.27422>:
      <D.27423>:
      <D.27424>:
      <D.27425>:
      <D.27426>:
      <D.27427>:
      <D.27428>:
      <D.27429>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.30924 = header->max_stack;
      D.31146 = (long int) D.30924;
      if (D.31014 >= D.31146) goto <D.31621>; else goto <D.31622>;
      <D.31621>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31623>; else goto <D.31624>;
      <D.31623>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31625>; else goto <D.31626>;
      <D.31625>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31626>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31624>:
      D.31627 = mini_get_debug_options ();
      D.31628 = D.31627->break_on_unverified;
      if (D.31628 != 0) goto <D.31629>; else goto unverified;
      <D.31629>:
      raise (5);
      <D.31622>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 362;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.31121 = *ip;
      D.31122 = (int) D.31121;
      D.31630 = D.31122 + -22;
      D.31631 = (long int) D.31630;
      ins->data.op[0].const_val = D.31631;
      ins->type = 1;
      D.31632 = alloc_dreg (cfg, 1);
      D.31633 = (int) D.31632;
      ins->dreg = D.31633;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.31634>; else goto <D.31635>;
      <D.31634>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.31636>;
      <D.31635>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.31636>:
      ip = ip + 1;
      sp.88 = sp;
      sp = sp.88 + 8;
      *sp.88 = ins;
      goto <D.27394>;
      <D.27430>:
      D.31251 = ip + 2;
      if (D.31251 > end) goto <D.31638>; else goto <D.31639>;
      <D.31638>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31640>; else goto <D.31641>;
      <D.31640>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31642>; else goto <D.31643>;
      <D.31642>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31643>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31641>:
      D.31644 = mini_get_debug_options ();
      D.31645 = D.31644->break_on_unverified;
      if (D.31645 != 0) goto <D.31646>; else goto unverified;
      <D.31646>:
      raise (5);
      <D.31639>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.30924 = header->max_stack;
      D.31146 = (long int) D.30924;
      if (D.31014 >= D.31146) goto <D.31647>; else goto <D.31648>;
      <D.31647>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31649>; else goto <D.31650>;
      <D.31649>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31651>; else goto <D.31652>;
      <D.31651>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31652>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31650>:
      D.31653 = mini_get_debug_options ();
      D.31654 = D.31653->break_on_unverified;
      if (D.31654 != 0) goto <D.31655>; else goto unverified;
      <D.31655>:
      raise (5);
      <D.31648>:
      ip = ip + 1;
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 362;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.31656 = MEM[(signed char *)ip];
      D.31657 = (long int) D.31656;
      ins->data.op[0].const_val = D.31657;
      ins->type = 1;
      D.31658 = alloc_dreg (cfg, 1);
      D.31659 = (int) D.31658;
      ins->dreg = D.31659;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.31660>; else goto <D.31661>;
      <D.31660>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.31662>;
      <D.31661>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.31662>:
      ip = ip + 1;
      sp.89 = sp;
      sp = sp.89 + 8;
      *sp.89 = ins;
      goto <D.27394>;
      <D.27431>:
      D.31664 = ip + 5;
      if (D.31664 > end) goto <D.31665>; else goto <D.31666>;
      <D.31665>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31667>; else goto <D.31668>;
      <D.31667>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31669>; else goto <D.31670>;
      <D.31669>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31670>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31668>:
      D.31671 = mini_get_debug_options ();
      D.31672 = D.31671->break_on_unverified;
      if (D.31672 != 0) goto <D.31673>; else goto unverified;
      <D.31673>:
      raise (5);
      <D.31666>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.30924 = header->max_stack;
      D.31146 = (long int) D.30924;
      if (D.31014 >= D.31146) goto <D.31674>; else goto <D.31675>;
      <D.31674>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31676>; else goto <D.31677>;
      <D.31676>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31678>; else goto <D.31679>;
      <D.31678>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31679>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31677>:
      D.31680 = mini_get_debug_options ();
      D.31681 = D.31680->break_on_unverified;
      if (D.31681 != 0) goto <D.31682>; else goto unverified;
      <D.31682>:
      raise (5);
      <D.31675>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 362;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31684 = D.31683 << 24;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31685 = D.31683 >> 8;
      D.31686 = D.31685 & 65280;
      D.31687 = D.31684 | D.31686;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31688 = D.31683 << 8;
      D.31689 = D.31688 & 16711680;
      D.31690 = D.31687 | D.31689;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31691 = D.31683 >> 24;
      D.31692 = D.31690 | D.31691;
      D.31693 = (int) D.31692;
      D.31694 = (long int) D.31693;
      ins->data.op[0].const_val = D.31694;
      ins->type = 1;
      D.31695 = alloc_dreg (cfg, 1);
      D.31696 = (int) D.31695;
      ins->dreg = D.31696;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.31697>; else goto <D.31698>;
      <D.31697>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.31699>;
      <D.31698>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.31699>:
      ip = ip + 5;
      sp.90 = sp;
      sp = sp.90 + 8;
      *sp.90 = ins;
      goto <D.27394>;
      <D.27432>:
      D.31701 = ip + 9;
      if (D.31701 > end) goto <D.31702>; else goto <D.31703>;
      <D.31702>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31704>; else goto <D.31705>;
      <D.31704>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31706>; else goto <D.31707>;
      <D.31706>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31707>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31705>:
      D.31708 = mini_get_debug_options ();
      D.31709 = D.31708->break_on_unverified;
      if (D.31709 != 0) goto <D.31710>; else goto unverified;
      <D.31710>:
      raise (5);
      <D.31703>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.30924 = header->max_stack;
      D.31146 = (long int) D.30924;
      if (D.31014 >= D.31146) goto <D.31711>; else goto <D.31712>;
      <D.31711>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31713>; else goto <D.31714>;
      <D.31713>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31715>; else goto <D.31716>;
      <D.31715>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31716>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31714>:
      D.31717 = mini_get_debug_options ();
      D.31718 = D.31717->break_on_unverified;
      if (D.31718 != 0) goto <D.31719>; else goto unverified;
      <D.31719>:
      raise (5);
      <D.31712>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 363;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      ins->type = 2;
      D.31720 = alloc_dreg (cfg, 2);
      D.31721 = (int) D.31720;
      ins->dreg = D.31721;
      ip = ip + 1;
      D.31722 = MEM[(const guint64 *)ip];
      D.31723 = (unsigned int) D.31722;
      D.31724 = D.31723 << 24;
      D.31722 = MEM[(const guint64 *)ip];
      D.31723 = (unsigned int) D.31722;
      D.31725 = D.31723 >> 8;
      D.31726 = D.31725 & 65280;
      D.31727 = D.31724 | D.31726;
      D.31722 = MEM[(const guint64 *)ip];
      D.31723 = (unsigned int) D.31722;
      D.31728 = D.31723 << 8;
      D.31729 = D.31728 & 16711680;
      D.31730 = D.31727 | D.31729;
      D.31722 = MEM[(const guint64 *)ip];
      D.31723 = (unsigned int) D.31722;
      D.31731 = D.31723 >> 24;
      D.31732 = D.31730 | D.31731;
      D.31733 = (long unsigned int) D.31732;
      D.31734 = D.31733 << 32;
      D.31722 = MEM[(const guint64 *)ip];
      D.31735 = D.31722 >> 32;
      D.31736 = (unsigned int) D.31735;
      D.31737 = D.31736 << 24;
      D.31722 = MEM[(const guint64 *)ip];
      D.31735 = D.31722 >> 32;
      D.31736 = (unsigned int) D.31735;
      D.31738 = D.31736 >> 8;
      D.31739 = D.31738 & 65280;
      D.31740 = D.31737 | D.31739;
      D.31722 = MEM[(const guint64 *)ip];
      D.31735 = D.31722 >> 32;
      D.31736 = (unsigned int) D.31735;
      D.31741 = D.31736 << 8;
      D.31742 = D.31741 & 16711680;
      D.31743 = D.31740 | D.31742;
      D.31722 = MEM[(const guint64 *)ip];
      D.31735 = D.31722 >> 32;
      D.31736 = (unsigned int) D.31735;
      D.31744 = D.31736 >> 24;
      D.31745 = D.31743 | D.31744;
      D.31746 = (long unsigned int) D.31745;
      D.31747 = D.31734 | D.31746;
      D.31748 = (long int) D.31747;
      ins->data.i8const = D.31748;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      if (D.30577 != 0B) goto <D.31749>; else goto <D.31750>;
      <D.31749>:
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      D.30577->next = ins;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      ins->prev = D.30577;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      goto <D.31751>;
      <D.31750>:
      bblock.64 = bblock;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      D.30577 = bblock.64->last_ins;
      bblock.64->code = D.30577;
      <D.31751>:
      ip = ip + 8;
      sp.91 = sp;
      sp = sp.91 + 8;
      *sp.91 = ins;
      goto <D.27394>;
      <D.27433>:
      {
        float * f;
        gboolean use_aotconst;

        use_aotconst = 0;
        D.30267 = cfg->domain;
        f = mono_domain_alloc (D.30267, 4);
        D.31664 = ip + 5;
        if (D.31664 > end) goto <D.31753>; else goto <D.31754>;
        <D.31753>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.31755>; else goto <D.31756>;
        <D.31755>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.31757>; else goto <D.31758>;
        <D.31757>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.31758>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.31756>:
        D.31759 = mini_get_debug_options ();
        D.31760 = D.31759->break_on_unverified;
        if (D.31760 != 0) goto <D.31761>; else goto unverified;
        <D.31761>:
        raise (5);
        <D.31754>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        D.31014 = D.31013 /[ex] 8;
        D.30924 = header->max_stack;
        D.31146 = (long int) D.30924;
        if (D.31014 >= D.31146) goto <D.31762>; else goto <D.31763>;
        <D.31762>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.31764>; else goto <D.31765>;
        <D.31764>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.31766>; else goto <D.31767>;
        <D.31766>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.31767>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.31765>:
        D.31768 = mini_get_debug_options ();
        D.31769 = D.31768->break_on_unverified;
        if (D.31769 != 0) goto <D.31770>; else goto unverified;
        <D.31770>:
        raise (5);
        <D.31763>:
        if (use_aotconst != 0) goto <D.31771>; else goto <D.31772>;
        <D.31771>:
        {
          struct MonoInst * cons;
          int dreg;

          D.30241 = cfg->mempool;
          cons = mono_mempool_alloc (D.30241, 80);
          cons->data.op[1].const_val = 0;
          D.31773 = cons->data.op[1].const_val;
          cons->data.op[0].const_val = D.31773;
          cons->prev = 0B;
          D.31774 = cons->prev;
          cons->next = D.31774;
          D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.30635 = D.30634 & 33554432;
          if (D.30635 != 0) goto <D.31776>; else goto <D.31777>;
          <D.31776>:
          iftmp.92 = 732;
          goto <D.31778>;
          <D.31777>:
          iftmp.92 = 363;
          <D.31778>:
          cons->opcode = iftmp.92;
          cons->flags = 0;
          cons->type = 0;
          cons->dreg = -1;
          cons->sreg3 = -1;
          D.31779 = cons->sreg3;
          cons->sreg2 = D.31779;
          D.31780 = cons->sreg2;
          cons->sreg1 = D.31780;
          D.30461 = cfg->ip;
          cons->cil_code = D.30461;
          cons->data.op[0].p = f;
          cons->data.op[1].src = 20B;
          cons->type = 3;
          D.31781 = alloc_dreg (cfg, 3);
          D.31782 = (int) D.31781;
          cons->dreg = D.31782;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.31783>; else goto <D.31784>;
          <D.31783>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = cons;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          cons->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = cons;
          goto <D.31785>;
          <D.31784>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = cons;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.31785>:
          D.31786 = alloc_freg (cfg);
          dreg = (int) D.31786;
          D.30241 = cfg->mempool;
          ins = mono_mempool_alloc (D.30241, 80);
          ins->data.op[1].const_val = 0;
          D.30457 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.30457;
          ins->prev = 0B;
          D.30458 = ins->prev;
          ins->next = D.30458;
          ins->opcode = 396;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.30459 = ins->sreg3;
          ins->sreg2 = D.30459;
          D.30460 = ins->sreg2;
          ins->sreg1 = D.30460;
          D.30461 = cfg->ip;
          ins->cil_code = D.30461;
          ins->dreg = dreg;
          D.31787 = cons->dreg;
          ins->sreg1 = D.31787;
          ins->data.op[0].const_val = 0;
          ins->type = 1;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.31788>; else goto <D.31789>;
          <D.31788>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = ins;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          ins->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          goto <D.31790>;
          <D.31789>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.31790>:
          ins->type = 4;
        }
        goto <D.31791>;
        <D.31772>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 364;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        ins->type = 4;
        D.31792 = alloc_dreg (cfg, 4);
        D.31793 = (int) D.31792;
        ins->dreg = D.31793;
        ins->data.op[0].p = f;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        if (D.30577 != 0B) goto <D.31794>; else goto <D.31795>;
        <D.31794>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        D.30577->next = ins;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        ins->prev = D.30577;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        goto <D.31796>;
        <D.31795>:
        bblock.64 = bblock;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        D.30577 = bblock.64->last_ins;
        bblock.64->code = D.30577;
        <D.31796>:
        <D.31791>:
        ip = ip + 1;
        {
          union mono_rfloat mf;

          try
            {
              D.31797 = MEM[(const guint32 *)ip];
              D.31798 = D.31797 << 24;
              D.31797 = MEM[(const guint32 *)ip];
              D.31799 = D.31797 >> 8;
              D.31800 = D.31799 & 65280;
              D.31801 = D.31798 | D.31800;
              D.31797 = MEM[(const guint32 *)ip];
              D.31802 = D.31797 << 8;
              D.31803 = D.31802 & 16711680;
              D.31804 = D.31801 | D.31803;
              D.31797 = MEM[(const guint32 *)ip];
              D.31805 = D.31797 >> 24;
              D.31806 = D.31804 | D.31805;
              mf.ival = D.31806;
              D.31807 = mf.fval;
              *f = D.31807;
            }
          finally
            {
              mf = {CLOBBER};
            }
        }
        ip = ip + 4;
        sp.93 = sp;
        sp = sp.93 + 8;
        *sp.93 = ins;
        goto <D.27394>;
      }
      <D.27439>:
      {
        double * d;
        gboolean use_aotconst;

        use_aotconst = 0;
        D.30267 = cfg->domain;
        d = mono_domain_alloc (D.30267, 8);
        D.31701 = ip + 9;
        if (D.31701 > end) goto <D.31809>; else goto <D.31810>;
        <D.31809>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.31811>; else goto <D.31812>;
        <D.31811>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.31813>; else goto <D.31814>;
        <D.31813>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.31814>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.31812>:
        D.31815 = mini_get_debug_options ();
        D.31816 = D.31815->break_on_unverified;
        if (D.31816 != 0) goto <D.31817>; else goto unverified;
        <D.31817>:
        raise (5);
        <D.31810>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        D.31014 = D.31013 /[ex] 8;
        D.30924 = header->max_stack;
        D.31146 = (long int) D.30924;
        if (D.31014 >= D.31146) goto <D.31818>; else goto <D.31819>;
        <D.31818>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.31820>; else goto <D.31821>;
        <D.31820>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.31822>; else goto <D.31823>;
        <D.31822>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.31823>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.31821>:
        D.31824 = mini_get_debug_options ();
        D.31825 = D.31824->break_on_unverified;
        if (D.31825 != 0) goto <D.31826>; else goto unverified;
        <D.31826>:
        raise (5);
        <D.31819>:
        if (use_aotconst != 0) goto <D.31827>; else goto <D.31828>;
        <D.31827>:
        {
          struct MonoInst * cons;
          int dreg;

          D.30241 = cfg->mempool;
          cons = mono_mempool_alloc (D.30241, 80);
          cons->data.op[1].const_val = 0;
          D.31829 = cons->data.op[1].const_val;
          cons->data.op[0].const_val = D.31829;
          cons->prev = 0B;
          D.31830 = cons->prev;
          cons->next = D.31830;
          D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.30635 = D.30634 & 33554432;
          if (D.30635 != 0) goto <D.31832>; else goto <D.31833>;
          <D.31832>:
          iftmp.94 = 732;
          goto <D.31834>;
          <D.31833>:
          iftmp.94 = 363;
          <D.31834>:
          cons->opcode = iftmp.94;
          cons->flags = 0;
          cons->type = 0;
          cons->dreg = -1;
          cons->sreg3 = -1;
          D.31835 = cons->sreg3;
          cons->sreg2 = D.31835;
          D.31836 = cons->sreg2;
          cons->sreg1 = D.31836;
          D.30461 = cfg->ip;
          cons->cil_code = D.30461;
          cons->data.op[0].p = d;
          cons->data.op[1].src = 21B;
          cons->type = 3;
          D.31837 = alloc_dreg (cfg, 3);
          D.31838 = (int) D.31837;
          cons->dreg = D.31838;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.31839>; else goto <D.31840>;
          <D.31839>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = cons;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          cons->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = cons;
          goto <D.31841>;
          <D.31840>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = cons;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.31841>:
          D.31842 = alloc_freg (cfg);
          dreg = (int) D.31842;
          D.30241 = cfg->mempool;
          ins = mono_mempool_alloc (D.30241, 80);
          ins->data.op[1].const_val = 0;
          D.30457 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.30457;
          ins->prev = 0B;
          D.30458 = ins->prev;
          ins->next = D.30458;
          ins->opcode = 397;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.30459 = ins->sreg3;
          ins->sreg2 = D.30459;
          D.30460 = ins->sreg2;
          ins->sreg1 = D.30460;
          D.30461 = cfg->ip;
          ins->cil_code = D.30461;
          ins->dreg = dreg;
          D.31843 = cons->dreg;
          ins->sreg1 = D.31843;
          ins->data.op[0].const_val = 0;
          ins->type = 1;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.31844>; else goto <D.31845>;
          <D.31844>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = ins;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          ins->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          goto <D.31846>;
          <D.31845>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.31846>:
          ins->type = 4;
        }
        goto <D.31847>;
        <D.31828>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 365;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        ins->type = 4;
        D.31848 = alloc_dreg (cfg, 4);
        D.31849 = (int) D.31848;
        ins->dreg = D.31849;
        ins->data.op[0].p = d;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        if (D.30577 != 0B) goto <D.31850>; else goto <D.31851>;
        <D.31850>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        D.30577->next = ins;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        ins->prev = D.30577;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        goto <D.31852>;
        <D.31851>:
        bblock.64 = bblock;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        D.30577 = bblock.64->last_ins;
        bblock.64->code = D.30577;
        <D.31852>:
        <D.31847>:
        ip = ip + 1;
        {
          union mono_rdouble mf;

          try
            {
              D.31722 = MEM[(const guint64 *)ip];
              D.31723 = (unsigned int) D.31722;
              D.31724 = D.31723 << 24;
              D.31722 = MEM[(const guint64 *)ip];
              D.31723 = (unsigned int) D.31722;
              D.31725 = D.31723 >> 8;
              D.31726 = D.31725 & 65280;
              D.31727 = D.31724 | D.31726;
              D.31722 = MEM[(const guint64 *)ip];
              D.31723 = (unsigned int) D.31722;
              D.31728 = D.31723 << 8;
              D.31729 = D.31728 & 16711680;
              D.31730 = D.31727 | D.31729;
              D.31722 = MEM[(const guint64 *)ip];
              D.31723 = (unsigned int) D.31722;
              D.31731 = D.31723 >> 24;
              D.31732 = D.31730 | D.31731;
              D.31733 = (long unsigned int) D.31732;
              D.31734 = D.31733 << 32;
              D.31722 = MEM[(const guint64 *)ip];
              D.31735 = D.31722 >> 32;
              D.31736 = (unsigned int) D.31735;
              D.31737 = D.31736 << 24;
              D.31722 = MEM[(const guint64 *)ip];
              D.31735 = D.31722 >> 32;
              D.31736 = (unsigned int) D.31735;
              D.31738 = D.31736 >> 8;
              D.31739 = D.31738 & 65280;
              D.31740 = D.31737 | D.31739;
              D.31722 = MEM[(const guint64 *)ip];
              D.31735 = D.31722 >> 32;
              D.31736 = (unsigned int) D.31735;
              D.31741 = D.31736 << 8;
              D.31742 = D.31741 & 16711680;
              D.31743 = D.31740 | D.31742;
              D.31722 = MEM[(const guint64 *)ip];
              D.31735 = D.31722 >> 32;
              D.31736 = (unsigned int) D.31735;
              D.31744 = D.31736 >> 24;
              D.31745 = D.31743 | D.31744;
              D.31746 = (long unsigned int) D.31745;
              D.31747 = D.31734 | D.31746;
              mf.ival = D.31747;
              D.31853 = mf.fval;
              *d = D.31853;
            }
          finally
            {
              mf = {CLOBBER};
            }
        }
        ip = ip + 8;
        sp.95 = sp;
        sp = sp.95 + 8;
        *sp.95 = ins;
        goto <D.27394>;
      }
      <D.27445>:
      {
        struct MonoInst * temp;
        struct MonoInst * store;

        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        if (D.31013 <= 7) goto <D.31855>; else goto <D.31856>;
        <D.31855>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.31857>; else goto <D.31858>;
        <D.31857>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.31859>; else goto <D.31860>;
        <D.31859>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.31860>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.31858>:
        D.31861 = mini_get_debug_options ();
        D.31862 = D.31861->break_on_unverified;
        if (D.31862 != 0) goto <D.31863>; else goto unverified;
        <D.31863>:
        raise (5);
        <D.31856>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        D.31014 = D.31013 /[ex] 8;
        D.30924 = header->max_stack;
        D.31146 = (long int) D.30924;
        if (D.31014 >= D.31146) goto <D.31864>; else goto <D.31865>;
        <D.31864>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.31866>; else goto <D.31867>;
        <D.31866>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.31868>; else goto <D.31869>;
        <D.31868>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.31869>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.31867>:
        D.31870 = mini_get_debug_options ();
        D.31871 = D.31870->break_on_unverified;
        if (D.31871 != 0) goto <D.31872>; else goto unverified;
        <D.31872>:
        raise (5);
        <D.31865>:
        sp = sp + 18446744073709551608;
        ins = *sp;
        D.31873 = type_from_stack_type (ins);
        temp = mono_compile_create_var (cfg, D.31873, 329);
        D.30241 = cfg->mempool;
        store = mono_mempool_alloc (D.30241, 80);
        store->data.op[1].const_val = 0;
        D.31874 = store->data.op[1].const_val;
        store->data.op[0].const_val = D.31874;
        store->prev = 0B;
        D.31875 = store->prev;
        store->next = D.31875;
        store->opcode = 424;
        store->flags = 0;
        store->type = 0;
        store->dreg = -1;
        store->sreg3 = -1;
        D.31876 = store->sreg3;
        store->sreg2 = D.31876;
        D.31877 = store->sreg2;
        store->sreg1 = D.31877;
        D.30461 = cfg->ip;
        store->cil_code = D.30461;
        D.30978 = cfg->varinfo;
        D.31878 = temp->data.op[0].const_val;
        D.31879 = (long unsigned int) D.31878;
        D.31880 = D.31879 * 8;
        D.31881 = D.30978 + D.31880;
        D.31882 = *D.31881;
        D.31883 = D.31882->data.op[1].vtype;
        D.31884 = mono_type_to_regmove (cfg, D.31883);
        D.31885 = (short unsigned int) D.31884;
        store->opcode = D.31885;
        D.30978 = cfg->varinfo;
        D.31878 = temp->data.op[0].const_val;
        D.31879 = (long unsigned int) D.31878;
        D.31880 = D.31879 * 8;
        D.31881 = D.30978 + D.31880;
        D.31882 = *D.31881;
        D.31886 = D.31882->klass;
        store->klass = D.31886;
        D.30654 = ins->dreg;
        store->sreg1 = D.30654;
        D.30978 = cfg->varinfo;
        D.31878 = temp->data.op[0].const_val;
        D.31879 = (long unsigned int) D.31878;
        D.31880 = D.31879 * 8;
        D.31881 = D.30978 + D.31880;
        D.31882 = *D.31881;
        D.31887 = D.31882->dreg;
        store->dreg = D.31887;
        D.31888 = store->opcode;
        if (D.31888 == 427) goto <D.31889>; else goto <D.31890>;
        <D.31889>:
        D.30978 = cfg->varinfo;
        D.31878 = temp->data.op[0].const_val;
        D.31879 = (long unsigned int) D.31878;
        D.31880 = D.31879 * 8;
        D.31881 = D.30978 + D.31880;
        D.31882 = *D.31881;
        D.31883 = D.31882->data.op[1].vtype;
        D.31891 = mono_class_from_mono_type (D.31883);
        store->klass = D.31891;
        <D.31890>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.31892>; else goto <D.31893>;
        <D.31892>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = store;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        store->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = store;
        goto <D.31894>;
        <D.31893>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = store;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.31894>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 424;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        D.30978 = cfg->varinfo;
        D.31878 = temp->data.op[0].const_val;
        D.31879 = (long unsigned int) D.31878;
        D.31880 = D.31879 * 8;
        D.31881 = D.30978 + D.31880;
        D.31882 = *D.31881;
        D.31883 = D.31882->data.op[1].vtype;
        D.31895 = mono_type_to_regmove (cfg, D.31883);
        D.31896 = (short unsigned int) D.31895;
        ins->opcode = D.31896;
        D.30978 = cfg->varinfo;
        D.31878 = temp->data.op[0].const_val;
        D.31879 = (long unsigned int) D.31878;
        D.31880 = D.31879 * 8;
        D.31881 = D.30978 + D.31880;
        D.31882 = *D.31881;
        D.31883 = D.31882->data.op[1].vtype;
        type_to_eval_stack_type (cfg, D.31883, ins);
        D.30978 = cfg->varinfo;
        D.31878 = temp->data.op[0].const_val;
        D.31879 = (long unsigned int) D.31878;
        D.31880 = D.31879 * 8;
        D.31881 = D.30978 + D.31880;
        D.31882 = *D.31881;
        D.31886 = D.31882->klass;
        ins->klass = D.31886;
        D.30978 = cfg->varinfo;
        D.31878 = temp->data.op[0].const_val;
        D.31879 = (long unsigned int) D.31878;
        D.31880 = D.31879 * 8;
        D.31881 = D.30978 + D.31880;
        D.31882 = *D.31881;
        D.31887 = D.31882->dreg;
        ins->sreg1 = D.31887;
        D.30988 = ins->type;
        D.30989 = (<unnamed type>) D.30988;
        D.31897 = alloc_dreg (cfg, D.30989);
        D.31898 = (int) D.31897;
        ins->dreg = D.31898;
        D.30992 = ins->opcode;
        if (D.30992 == 427) goto <D.31899>; else goto <D.31900>;
        <D.31899>:
        D.30978 = cfg->varinfo;
        D.31878 = temp->data.op[0].const_val;
        D.31879 = (long unsigned int) D.31878;
        D.31880 = D.31879 * 8;
        D.31881 = D.30978 + D.31880;
        D.31882 = *D.31881;
        D.31883 = D.31882->data.op[1].vtype;
        D.31901 = mono_class_from_mono_type (D.31883);
        ins->klass = D.31901;
        <D.31900>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.31902>; else goto <D.31903>;
        <D.31902>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.31904>;
        <D.31903>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.31904>:
        sp.96 = sp;
        sp = sp.96 + 8;
        *sp.96 = ins;
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 424;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        D.30978 = cfg->varinfo;
        D.31878 = temp->data.op[0].const_val;
        D.31879 = (long unsigned int) D.31878;
        D.31880 = D.31879 * 8;
        D.31881 = D.30978 + D.31880;
        D.31882 = *D.31881;
        D.31883 = D.31882->data.op[1].vtype;
        D.31906 = mono_type_to_regmove (cfg, D.31883);
        D.31907 = (short unsigned int) D.31906;
        ins->opcode = D.31907;
        D.30978 = cfg->varinfo;
        D.31878 = temp->data.op[0].const_val;
        D.31879 = (long unsigned int) D.31878;
        D.31880 = D.31879 * 8;
        D.31881 = D.30978 + D.31880;
        D.31882 = *D.31881;
        D.31883 = D.31882->data.op[1].vtype;
        type_to_eval_stack_type (cfg, D.31883, ins);
        D.30978 = cfg->varinfo;
        D.31878 = temp->data.op[0].const_val;
        D.31879 = (long unsigned int) D.31878;
        D.31880 = D.31879 * 8;
        D.31881 = D.30978 + D.31880;
        D.31882 = *D.31881;
        D.31886 = D.31882->klass;
        ins->klass = D.31886;
        D.30978 = cfg->varinfo;
        D.31878 = temp->data.op[0].const_val;
        D.31879 = (long unsigned int) D.31878;
        D.31880 = D.31879 * 8;
        D.31881 = D.30978 + D.31880;
        D.31882 = *D.31881;
        D.31887 = D.31882->dreg;
        ins->sreg1 = D.31887;
        D.30988 = ins->type;
        D.30989 = (<unnamed type>) D.30988;
        D.31908 = alloc_dreg (cfg, D.30989);
        D.31909 = (int) D.31908;
        ins->dreg = D.31909;
        D.30992 = ins->opcode;
        if (D.30992 == 427) goto <D.31910>; else goto <D.31911>;
        <D.31910>:
        D.30978 = cfg->varinfo;
        D.31878 = temp->data.op[0].const_val;
        D.31879 = (long unsigned int) D.31878;
        D.31880 = D.31879 * 8;
        D.31881 = D.30978 + D.31880;
        D.31882 = *D.31881;
        D.31883 = D.31882->data.op[1].vtype;
        D.31912 = mono_class_from_mono_type (D.31883);
        ins->klass = D.31912;
        <D.31911>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.31913>; else goto <D.31914>;
        <D.31913>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.31915>;
        <D.31914>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.31915>:
        sp.97 = sp;
        sp = sp.97 + 8;
        *sp.97 = ins;
        ip = ip + 1;
        inline_costs = inline_costs + 2;
        goto <D.27394>;
      }
      <D.27448>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.31917>; else goto <D.31918>;
      <D.31917>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.31919>; else goto <D.31920>;
      <D.31919>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.31921>; else goto <D.31922>;
      <D.31921>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.31922>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.31920>:
      D.31923 = mini_get_debug_options ();
      D.31924 = D.31923->break_on_unverified;
      if (D.31924 != 0) goto <D.31925>; else goto unverified;
      <D.31925>:
      raise (5);
      <D.31918>:
      ip = ip + 1;
      sp = sp + 18446744073709551608;
      goto <D.27394>;
      <D.27449>:
      {
        struct MonoCallInst * call;

        D.30211 = cfg->method;
        if (D.30211 != method) goto <D.31926>; else goto <D.31927>;
        <D.31926>:
        D.30183 = BIT_FIELD_REF <*method, 64, 256>;
        D.30184 = D.30183 & 4467570830351532032;
        if (D.30184 == 0) goto <D.31928>; else goto <D.31929>;
        <D.31928>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 1) goto <D.31930>; else goto <D.31931>;
        <D.31930>:
        printf ("inline failed: %s\n", "jmp");
        <D.31931>:
        goto inline_failure;
        <D.31929>:
        <D.31927>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.31932>; else goto <D.31933>;
        <D.31932>:
        D.30178 = method->klass;
        D.31934 = D.30178->name_space;
        D.30178 = method->klass;
        D.31935 = D.30178->name;
        D.31936 = method->name;
        D.31937 = method->signature;
        D.31938 = D.31937->param_count;
        D.31939 = (int) D.31938;
        D.31121 = *ip;
        D.31122 = (int) D.31121;
        D.31940 = mono_opcode_name (D.31122);
        D.31941 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.31934, D.31935, D.31936, D.31939, D.31940, "method-to-ir.c", 7539);
        cfg->exception_message = D.31941;
        D.30322 = cfg->verbose_level;
        if (D.30322 > 1) goto <D.31942>; else goto <D.31943>;
        <D.31942>:
        D.31944 = cfg->exception_message;
        printf ("%s\n", D.31944);
        <D.31943>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.31933>:
        D.31664 = ip + 5;
        if (D.31664 > end) goto <D.31945>; else goto <D.31946>;
        <D.31945>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.31947>; else goto <D.31948>;
        <D.31947>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.31949>; else goto <D.31950>;
        <D.31949>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.31950>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.31948>:
        D.31951 = mini_get_debug_options ();
        D.31952 = D.31951->break_on_unverified;
        if (D.31952 != 0) goto <D.31953>; else goto unverified;
        <D.31953>:
        raise (5);
        <D.31946>:
        if (stack_start != sp) goto <D.31954>; else goto <D.31955>;
        <D.31954>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.31956>; else goto <D.31957>;
        <D.31956>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.31958>; else goto <D.31959>;
        <D.31958>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.31959>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.31957>:
        D.31960 = mini_get_debug_options ();
        D.31961 = D.31960->break_on_unverified;
        if (D.31961 != 0) goto <D.31962>; else goto unverified;
        <D.31962>:
        raise (5);
        <D.31955>:
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31684 = D.31683 << 24;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31685 = D.31683 >> 8;
        D.31686 = D.31685 & 65280;
        D.31687 = D.31684 | D.31686;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31688 = D.31683 << 8;
        D.31689 = D.31688 & 16711680;
        D.31690 = D.31687 | D.31689;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31691 = D.31683 >> 24;
        token = D.31690 | D.31691;
        cmethod = mini_get_method (cfg, method, token, 0B, generic_context);
        if (cmethod == 0B) goto <D.31963>; else goto <D.31965>;
        <D.31965>:
        D.31966 = mono_loader_get_last_error ();
        if (D.31966 != 0B) goto <D.31963>; else goto <D.31964>;
        <D.31963>:
        D.31967 = mini_get_debug_options ();
        D.31968 = D.31967->break_on_unverified;
        if (D.31968 != 0) goto <D.31969>; else goto load_error;
        <D.31969>:
        raise (5);
        <D.31964>:
        D.30278 = cfg->generic_sharing_context;
        if (D.30278 != 0B) goto <D.31970>; else goto <D.31971>;
        <D.31970>:
        D.31972 = mono_method_check_context_used (cmethod);
        if (D.31972 != 0) goto <D.31973>; else goto <D.31974>;
        <D.31973>:
        D.30278 = cfg->generic_sharing_context;
        if (D.30278 != 0B) goto <D.31975>; else goto <D.31976>;
        <D.31975>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.31977>; else goto <D.31978>;
        <D.31977>:
        D.30178 = method->klass;
        D.31934 = D.30178->name_space;
        D.30178 = method->klass;
        D.31935 = D.30178->name;
        D.31936 = method->name;
        D.31937 = method->signature;
        D.31938 = D.31937->param_count;
        D.31939 = (int) D.31938;
        D.31979 = mono_opcode_name (39);
        printf ("sharing failed for method %s.%s.%s/%d opcode %s line %d\n", D.31934, D.31935, D.31936, D.31939, D.31979, 7552);
        <D.31978>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.31976>:
        <D.31974>:
        <D.31971>:
        D.31980 = mono_security_get_mode ();
        if (D.31980 == 2) goto <D.31981>; else goto <D.31982>;
        <D.31981>:
        D.30793 = cfg->exception_type;
        if (D.30793 != 0) goto exception_exit; else goto <D.31983>;
        <D.31983>:
        <D.31982>:
        if (0 != 0) goto <D.31984>; else goto <D.31985>;
        <D.31984>:
        {
          struct MonoMethodSignature * fsig;
          int i;
          int n;

          fsig = mono_method_signature (cmethod);
          D.31986 = fsig->param_count;
          D.31987 = (int) D.31986;
          D.31988 = fsig->hasthis;
          D.31989 = (int) D.31988;
          n = D.31987 + D.31989;
          D.30322 = cfg->verbose_level;
          if (D.30322 > 1) goto <D.31990>; else goto <D.31991>;
          <D.31990>:
          printf ("AOT disabled: %s:%d\n", "method-to-ir.c", 7564);
          <D.31991>:
          cfg->disable_aot = 1;
          D.30241 = cfg->mempool;
          call = mono_mempool_alloc0 (D.30241, 192);
          call->inst.opcode = 444;
          call->inst.dreg = -1;
          call->inst.sreg3 = -1;
          D.31992 = call->inst.sreg3;
          call->inst.sreg2 = D.31992;
          D.31993 = call->inst.sreg2;
          call->inst.sreg1 = D.31993;
          D.30461 = cfg->ip;
          call->inst.cil_code = D.30461;
          call->method = cmethod;
          call->tail_call = 1;
          D.31994 = mono_method_signature (cmethod);
          call->signature = D.31994;
          D.30241 = cfg->mempool;
          D.31995 = (long unsigned int) n;
          D.31996 = (unsigned int) D.31995;
          D.31997 = D.31996 * 8;
          D.31998 = mono_mempool_alloc (D.30241, D.31997);
          call->args = D.31998;
          call->inst.data.op[0].p = cmethod;
          i = 0;
          goto <D.27457>;
          <D.27456>:
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.30241 = cfg->mempool;
          D.32003 = mono_mempool_alloc (D.30241, 80);
          *D.32002 = D.32003;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.32004->data.op[1].const_val = 0;
          D.32005 = D.32004->data.op[1].const_val;
          D.32004->data.op[0].const_val = D.32005;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.32004->prev = 0B;
          D.32006 = D.32004->prev;
          D.32004->next = D.32006;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.32004->opcode = 424;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.32004->flags = 0;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.32004->type = 0;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.32004->dreg = -1;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.32004->sreg3 = -1;
          D.32007 = D.32004->sreg3;
          D.32004->sreg2 = D.32007;
          D.32008 = D.32004->sreg2;
          D.32004->sreg1 = D.32008;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.30461 = cfg->ip;
          D.32004->cil_code = D.30461;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.30852 = cfg->arg_types;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32009 = D.30852 + D.32001;
          D.32010 = *D.32009;
          D.32011 = mono_type_to_regmove (cfg, D.32010);
          D.32012 = (short unsigned int) D.32011;
          D.32004->opcode = D.32012;
          D.30852 = cfg->arg_types;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32009 = D.30852 + D.32001;
          D.32010 = *D.32009;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          type_to_eval_stack_type (cfg, D.32010, D.32004);
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.30842 = cfg->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32013 = D.30842 + D.32001;
          D.32014 = *D.32013;
          D.32015 = D.32014->klass;
          D.32004->klass = D.32015;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.30842 = cfg->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32013 = D.30842 + D.32001;
          D.32014 = *D.32013;
          D.32016 = D.32014->dreg;
          D.32004->sreg1 = D.32016;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.32017 = D.32004->type;
          D.32018 = (<unnamed type>) D.32017;
          D.32019 = alloc_dreg (cfg, D.32018);
          D.32020 = (int) D.32019;
          D.32004->dreg = D.32020;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.32021 = D.32004->opcode;
          if (D.32021 == 427) goto <D.32022>; else goto <D.32023>;
          <D.32022>:
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.30852 = cfg->arg_types;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32009 = D.30852 + D.32001;
          D.32010 = *D.32009;
          D.32024 = mono_class_from_mono_type (D.32010);
          D.32004->klass = D.32024;
          <D.32023>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.32025>; else goto <D.32026>;
          <D.32025>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          D.30490->next = D.32004;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.32004->prev = D.30490;
          bblock.106 = cfg->cbb;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          bblock.106->last_ins = D.32004;
          goto <D.32027>;
          <D.32026>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          D.31999 = call->args;
          D.32000 = (long unsigned int) i;
          D.32001 = D.32000 * 8;
          D.32002 = D.31999 + D.32001;
          D.32004 = *D.32002;
          bblock.106->last_ins = D.32004;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.32027>:
          i = i + 1;
          <D.27457>:
          if (i < n) goto <D.27456>; else goto <D.27458>;
          <D.27458>:
          mono_arch_emit_call (cfg, call);
          bblock.64 = bblock;
          D.30577 = bblock.64->last_ins;
          if (D.30577 != 0B) goto <D.32028>; else goto <D.32029>;
          <D.32028>:
          bblock.64 = bblock;
          D.30577 = bblock.64->last_ins;
          D.30577->next = call;
          bblock.64 = bblock;
          D.30577 = bblock.64->last_ins;
          MEM[(struct MonoInst *)call].prev = D.30577;
          bblock.64 = bblock;
          bblock.64->last_ins = call;
          goto <D.32030>;
          <D.32029>:
          bblock.64 = bblock;
          bblock.64 = bblock;
          bblock.64->last_ins = call;
          D.30577 = bblock.64->last_ins;
          bblock.64->code = D.30577;
          <D.32030>:
        }
        goto <D.32031>;
        <D.31985>:
        i = 0;
        goto <D.27460>;
        <D.27459>:
        D.30370 = (long unsigned int) i;
        D.30973 = D.30370 * 8;
        D.32032 = arg_array + D.30973;
        D.32033 = *D.32032;
        D.30370 = (long unsigned int) i;
        D.30973 = D.30370 * 8;
        D.32032 = arg_array + D.30973;
        D.32033 = *D.32032;
        D.32034 = D.32033->flags;
        D.32035 = D.32034 | 4;
        D.32033->flags = D.32035;
        i = i + 1;
        <D.27460>:
        i.98 = (unsigned int) i;
        if (i.98 < num_args) goto <D.27459>; else goto <D.27461>;
        <D.27461>:
        D.30241 = cfg->mempool;
        call = mono_mempool_alloc0 (D.30241, 192);
        call->inst.opcode = 443;
        call->inst.dreg = -1;
        call->inst.sreg3 = -1;
        D.31992 = call->inst.sreg3;
        call->inst.sreg2 = D.31992;
        D.31993 = call->inst.sreg2;
        call->inst.sreg1 = D.31993;
        D.30461 = cfg->ip;
        call->inst.cil_code = D.30461;
        ins = call;
        ins->data.op[0].p = cmethod;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        if (D.30577 != 0B) goto <D.32037>; else goto <D.32038>;
        <D.32037>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        D.30577->next = ins;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        ins->prev = D.30577;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        goto <D.32039>;
        <D.32038>:
        bblock.64 = bblock;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        D.30577 = bblock.64->last_ins;
        bblock.64->code = D.30577;
        <D.32039>:
        <D.32031>:
        ip = ip + 5;
        start_new_bblock = 1;
        goto <D.27394>;
      }
      <D.27462>:
      <D.27463>:
      <D.27464>:
      {
        struct MonoInst * addr;
        struct MonoMethodSignature * fsig;
        int array_rank;
        int virtual;
        int calli;
        gboolean pass_imt_from_rgctx;
        struct MonoInst * imt_arg;
        struct MonoInst * keep_this_alive;
        gboolean pass_vtable;
        gboolean pass_mrgctx;
        struct MonoInst * vtable_arg;
        gboolean check_this;
        gboolean supported_tail_call;
        gboolean tail_call;
        gboolean need_seq_point;
        guint32 call_opcode;
        gboolean emit_widen;
        gboolean push_res;
        gboolean skip_ret;
        gboolean delegate_invoke;

        try
          {
            addr = 0B;
            fsig = 0B;
            array_rank = 0;
            D.31121 = *ip;
            D.32040 = D.31121 == 111;
            virtual = (int) D.32040;
            D.31121 = *ip;
            D.32041 = D.31121 == 41;
            calli = (int) D.32041;
            pass_imt_from_rgctx = 0;
            imt_arg = 0B;
            keep_this_alive = 0B;
            pass_vtable = 0;
            pass_mrgctx = 0;
            vtable_arg = 0B;
            check_this = 0;
            supported_tail_call = 0;
            tail_call = 0;
            need_seq_point = 0;
            D.31121 = *ip;
            call_opcode = (guint32) D.31121;
            emit_widen = 1;
            push_res = 1;
            skip_ret = 0;
            delegate_invoke = 0;
            D.31664 = ip + 5;
            if (D.31664 > end) goto <D.32042>; else goto <D.32043>;
            <D.32042>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.32044>; else goto <D.32045>;
            <D.32044>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.32046>; else goto <D.32047>;
            <D.32046>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.32047>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.32045>:
            D.32048 = mini_get_debug_options ();
            D.32049 = D.32048->break_on_unverified;
            if (D.32049 != 0) goto <D.32050>; else goto unverified;
            <D.32050>:
            raise (5);
            <D.32043>:
            D.31270 = ip + 1;
            D.31683 = MEM[(const guint32 *)D.31270];
            D.31684 = D.31683 << 24;
            D.31270 = ip + 1;
            D.31683 = MEM[(const guint32 *)D.31270];
            D.31685 = D.31683 >> 8;
            D.31686 = D.31685 & 65280;
            D.31687 = D.31684 | D.31686;
            D.31270 = ip + 1;
            D.31683 = MEM[(const guint32 *)D.31270];
            D.31688 = D.31683 << 8;
            D.31689 = D.31688 & 16711680;
            D.31690 = D.31687 | D.31689;
            D.31270 = ip + 1;
            D.31683 = MEM[(const guint32 *)D.31270];
            D.31691 = D.31683 >> 24;
            token = D.31690 | D.31691;
            ins = 0B;
            if (calli != 0) goto <D.32051>; else goto <D.32052>;
            <D.32051>:
            cmethod = 0B;
            sp.71 = (long int) sp;
            stack_start.72 = (long int) stack_start;
            D.31013 = sp.71 - stack_start.72;
            if (D.31013 <= 7) goto <D.32053>; else goto <D.32054>;
            <D.32053>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.32055>; else goto <D.32056>;
            <D.32055>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.32057>; else goto <D.32058>;
            <D.32057>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.32058>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.32056>:
            D.32059 = mini_get_debug_options ();
            D.32060 = D.32059->break_on_unverified;
            if (D.32060 != 0) goto <D.32061>; else goto unverified;
            <D.32061>:
            raise (5);
            <D.32054>:
            sp = sp + 18446744073709551608;
            addr = *sp;
            fsig = mini_get_signature (method, token, generic_context);
            D.32062 = fsig->param_count;
            D.32063 = (int) D.32062;
            D.32064 = fsig->hasthis;
            D.32065 = (int) D.32064;
            n = D.32063 + D.32065;
            D.30183 = BIT_FIELD_REF <*method, 64, 256>;
            D.32066 = D.30183 & 18014398509481984;
            if (D.32066 != 0) goto <D.32067>; else goto <D.32068>;
            <D.32067>:
            D.32069 = BIT_FIELD_REF <*fsig, 64, 64>;
            D.32070 = D.32069 & 128;
            if (D.32070 != 0) goto <D.32071>; else goto <D.32072>;
            <D.32071>:
            {
              struct MonoInst * args[3];

              try
                {
                  D.30241 = cfg->mempool;
                  D.32073 = mono_mempool_alloc (D.30241, 80);
                  args[0] = D.32073;
                  D.32074 = args[0];
                  D.32074 = args[0];
                  D.32074->data.op[1].const_val = 0;
                  D.32075 = D.32074->data.op[1].const_val;
                  D.32074->data.op[0].const_val = D.32075;
                  D.32074 = args[0];
                  D.32074 = args[0];
                  D.32074->prev = 0B;
                  D.32076 = D.32074->prev;
                  D.32074->next = D.32076;
                  D.32074 = args[0];
                  D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
                  D.30635 = D.30634 & 33554432;
                  if (D.30635 != 0) goto <D.32078>; else goto <D.32079>;
                  <D.32078>:
                  iftmp.99 = 732;
                  goto <D.32080>;
                  <D.32079>:
                  iftmp.99 = 363;
                  <D.32080>:
                  D.32074->opcode = iftmp.99;
                  D.32074 = args[0];
                  D.32074->flags = 0;
                  D.32074 = args[0];
                  D.32074->type = 0;
                  D.32074 = args[0];
                  D.32074->dreg = -1;
                  D.32074 = args[0];
                  D.32074 = args[0];
                  D.32074 = args[0];
                  D.32074->sreg3 = -1;
                  D.32081 = D.32074->sreg3;
                  D.32074->sreg2 = D.32081;
                  D.32082 = D.32074->sreg2;
                  D.32074->sreg1 = D.32082;
                  D.32074 = args[0];
                  D.30461 = cfg->ip;
                  D.32074->cil_code = D.30461;
                  D.32074 = args[0];
                  D.30178 = method->klass;
                  D.30179 = D.30178->image;
                  D.32074->data.op[0].p = D.30179;
                  D.32074 = args[0];
                  D.32074->data.op[1].src = 12B;
                  D.32074 = args[0];
                  D.32074->type = 3;
                  D.32074 = args[0];
                  D.32083 = alloc_dreg (cfg, 3);
                  D.32084 = (int) D.32083;
                  D.32074->dreg = D.32084;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.32085>; else goto <D.32086>;
                  <D.32085>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.32074 = args[0];
                  D.30490->next = D.32074;
                  D.32074 = args[0];
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.32074->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  D.32074 = args[0];
                  bblock.106->last_ins = D.32074;
                  goto <D.32087>;
                  <D.32086>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  D.32074 = args[0];
                  bblock.106->last_ins = D.32074;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.32087>:
                  D.30241 = cfg->mempool;
                  D.32088 = mono_mempool_alloc (D.30241, 80);
                  args[1] = D.32088;
                  D.32089 = args[1];
                  D.32089 = args[1];
                  D.32089->data.op[1].const_val = 0;
                  D.32090 = D.32089->data.op[1].const_val;
                  D.32089->data.op[0].const_val = D.32090;
                  D.32089 = args[1];
                  D.32089 = args[1];
                  D.32089->prev = 0B;
                  D.32091 = D.32089->prev;
                  D.32089->next = D.32091;
                  D.32089 = args[1];
                  D.32089->opcode = 363;
                  D.32089 = args[1];
                  D.32089->flags = 0;
                  D.32089 = args[1];
                  D.32089->type = 0;
                  D.32089 = args[1];
                  D.32089->dreg = -1;
                  D.32089 = args[1];
                  D.32089 = args[1];
                  D.32089 = args[1];
                  D.32089->sreg3 = -1;
                  D.32092 = D.32089->sreg3;
                  D.32089->sreg2 = D.32092;
                  D.32093 = D.32089->sreg2;
                  D.32089->sreg1 = D.32093;
                  D.32089 = args[1];
                  D.30461 = cfg->ip;
                  D.32089->cil_code = D.30461;
                  D.32089 = args[1];
                  D.32089->data.op[0].p = fsig;
                  D.32089 = args[1];
                  D.32089->type = 3;
                  D.32089 = args[1];
                  D.32094 = alloc_dreg (cfg, 3);
                  D.32095 = (int) D.32094;
                  D.32089->dreg = D.32095;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.32096>; else goto <D.32097>;
                  <D.32096>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.32089 = args[1];
                  D.30490->next = D.32089;
                  D.32089 = args[1];
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.32089->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  D.32089 = args[1];
                  bblock.106->last_ins = D.32089;
                  goto <D.32098>;
                  <D.32097>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  D.32089 = args[1];
                  bblock.106->last_ins = D.32089;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.32098>:
                  args[2] = addr;
                  addr = mono_emit_jit_icall (cfg, mono_get_native_calli_wrapper, &args);
                }
              finally
                {
                  args = {CLOBBER};
                }
            }
            <D.32072>:
            <D.32068>:
            goto <D.32099>;
            <D.32052>:
            {
              struct MonoMethod * cil_method;

              try
                {
                  cmethod = mini_get_method (cfg, method, token, 0B, generic_context);
                  cil_method = cmethod;
                  if (constrained_call != 0B) goto <D.32100>; else goto <D.32101>;
                  <D.32100>:
                  D.30183 = BIT_FIELD_REF <*method, 64, 256>;
                  D.30184 = D.30183 & 4467570830351532032;
                  if (D.30184 != 0) goto <D.32102>; else goto <D.32103>;
                  <D.32102>:
                  D.30322 = cfg->verbose_level;
                  if (D.30322 > 2) goto <D.32104>; else goto <D.32105>;
                  <D.32104>:
                  D.32106 = mono_type_get_full_name (constrained_call);
                  printf ("DM Constrained call to %s\n", D.32106);
                  <D.32105>:
                  D.32110 = constrained_call->byval_arg.type;
                  if (D.32110 != 19) goto <D.32111>; else goto <D.32107>;
                  <D.32111>:
                  D.32110 = constrained_call->byval_arg.type;
                  if (D.32110 != 30) goto <D.32108>; else goto <D.32107>;
                  <D.32107>:
                  D.30278 = cfg->generic_sharing_context;
                  if (D.30278 == 0B) goto <D.32108>; else goto <D.32109>;
                  <D.32108>:
                  cil_method.100 = cil_method;
                  cmethod = mono_get_method_constrained_with_method (image, cil_method.100, constrained_call, generic_context);
                  <D.32109>:
                  goto <D.32113>;
                  <D.32103>:
                  D.30322 = cfg->verbose_level;
                  if (D.30322 > 2) goto <D.32114>; else goto <D.32115>;
                  <D.32114>:
                  D.32116 = mono_type_get_full_name (constrained_call);
                  printf ("Constrained call to %s\n", D.32116);
                  <D.32115>:
                  D.32110 = constrained_call->byval_arg.type;
                  if (D.32110 == 19) goto <D.32117>; else goto <D.32120>;
                  <D.32120>:
                  D.32110 = constrained_call->byval_arg.type;
                  if (D.32110 == 30) goto <D.32117>; else goto <D.32118>;
                  <D.32117>:
                  D.30278 = cfg->generic_sharing_context;
                  if (D.30278 != 0B) goto <D.32121>; else goto <D.32118>;
                  <D.32121>:
                  D.32122 = mini_is_gsharedvt_klass (cfg, constrained_call);
                  if (D.32122 == 0) goto <D.32123>; else goto <D.32124>;
                  <D.32123>:
                  D.32125 = cmethod->klass;
                  D.32126 = BIT_FIELD_REF <*D.32125, 64, 256>;
                  D.32127 = D.32126 & 1152921504606846976;
                  D.32128 = D.32127 != 0;
                  D.32129 = (long int) D.32128;
                  D.32130 = __builtin_expect (D.32129, 0);
                  if (D.32130 != 0) goto <D.32131>; else goto <D.32132>;
                  <D.32131>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7671, "!cmethod->klass->valuetype");
                  <D.32132>:
                  <D.32124>:
                  goto <D.32119>;
                  <D.32118>:
                  cmethod = mono_get_method_constrained (image, token, constrained_call, generic_context, &cil_method);
                  <D.32119>:
                  <D.32113>:
                  <D.32101>:
                  if (cmethod == 0B) goto <D.32133>; else goto <D.32135>;
                  <D.32135>:
                  D.32136 = mono_loader_get_last_error ();
                  if (D.32136 != 0B) goto <D.32133>; else goto <D.32134>;
                  <D.32133>:
                  D.32137 = mini_get_debug_options ();
                  D.32138 = D.32137->break_on_unverified;
                  if (D.32138 != 0) goto <D.32139>; else goto load_error;
                  <D.32139>:
                  raise (5);
                  <D.32134>:
                  if (dont_verify == 0) goto <D.32140>; else goto <D.32141>;
                  <D.32140>:
                  D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
                  D.32142 = D.30634 & 131072;
                  if (D.32142 == 0) goto <D.32143>; else goto <D.32144>;
                  <D.32143>:
                  {
                    struct MonoMethod * target_method;

                    target_method = cil_method;
                    D.30183 = BIT_FIELD_REF <*method, 64, 256>;
                    D.30292 = D.30183 & 2251799813685248;
                    if (D.30292 != 0) goto <D.32145>; else goto <D.32146>;
                    <D.32145>:
                    D.32147 = mono_method_get_generic_container (method_definition);
                    D.32148 = &D.32147->context;
                    target_method = mini_get_method_allow_open (method, token, 0B, D.32148);
                    <D.32146>:
                    D.32149 = mono_method_can_access_method (method_definition, target_method);
                    if (D.32149 == 0) goto <D.32150>; else goto <D.32151>;
                    <D.32150>:
                    cil_method.100 = cil_method;
                    D.32152 = mono_method_can_access_method (method, cil_method.100);
                    if (D.32152 == 0) goto <D.32153>; else goto <D.32154>;
                    <D.32153>:
                    {
                      char * method_fname;
                      char * cil_method_fname;

                      method_fname = mono_method_full_name (method, 1);
                      cil_method.100 = cil_method;
                      cil_method_fname = mono_method_full_name (cil_method.100, 1);
                      mono_cfg_set_exception (cfg, 9);
                      D.32155 = monoeg_g_strdup_printf ("Method `%s\' is inaccessible from method `%s\'\n", cil_method_fname, method_fname);
                      cfg->exception_message = D.32155;
                      monoeg_g_free (method_fname);
                      monoeg_g_free (cil_method_fname);
                      goto exception_exit;
                    }
                    <D.32154>:
                    <D.32151>:
                  }
                  <D.32144>:
                  <D.32141>:
                  D.32156 = mono_security_get_mode ();
                  if (D.32156 == 1) goto <D.32157>; else goto <D.32158>;
                  <D.32157>:
                  cil_method.100 = cil_method;
                  bblock.64 = bblock;
                  ensure_method_is_allowed_to_call_method (cfg, method, cil_method.100, bblock.64, ip);
                  <D.32158>:
                  if (virtual == 0) goto <D.32159>; else goto <D.32160>;
                  <D.32159>:
                  D.32161 = cmethod->flags;
                  D.32162 = (int) D.32161;
                  D.32163 = D.32162 & 1024;
                  if (D.32163 != 0) goto <D.32164>; else goto <D.32165>;
                  <D.32164>:
                  virtual = 1;
                  <D.32165>:
                  <D.32160>:
                  {
                    const int test_flags;
                    const int expected_flags;

                    test_flags = 112;
                    expected_flags = 96;
                    if (virtual == 0) goto <D.32166>; else goto <D.32167>;
                    <D.32166>:
                    D.32125 = cmethod->klass;
                    D.32126 = BIT_FIELD_REF <*D.32125, 64, 256>;
                    D.32168 = D.32126 & 2199023255552;
                    if (D.32168 != 0) goto <D.32169>; else goto <D.32170>;
                    <D.32169>:
                    D.32161 = cmethod->flags;
                    D.32162 = (int) D.32161;
                    D.32171 = D.32162 & 112;
                    if (D.32171 == 96) goto <D.32172>; else goto <D.32173>;
                    <D.32172>:
                    D.30211 = cfg->method;
                    D.32174 = BIT_FIELD_REF <*D.30211, 64, 256>;
                    D.32175 = D.32174 & 4467570830351532032;
                    if (D.32175 == 0) goto <D.32176>; else goto <D.32177>;
                    <D.32176>:
                    virtual = 1;
                    <D.32177>:
                    <D.32173>:
                    <D.32170>:
                    <D.32167>:
                  }
                  D.32125 = cmethod->klass;
                  D.32126 = BIT_FIELD_REF <*D.32125, 64, 256>;
                  D.32178 = D.32126 & 9223372036854775808;
                  if (D.32178 == 0) goto <D.32179>; else goto <D.32180>;
                  <D.32179>:
                  D.32125 = cmethod->klass;
                  D.32181 = mono_class_init (D.32125);
                  if (D.32181 == 0) goto <D.32182>; else goto <D.32183>;
                  <D.32182>:
                  D.32184 = mini_get_debug_options ();
                  D.32185 = D.32184->break_on_unverified;
                  if (D.32185 != 0) goto <D.32186>; else goto <D.32187>;
                  <D.32186>:
                  raise (5);
                  goto <D.32188>;
                  <D.32187>:
                  D.32125 = cmethod->klass;
                  cfg->exception_ptr = D.32125;
                  goto load_error;
                  <D.32188>:
                  <D.32183>:
                  <D.32180>:
                  D.32191 = cmethod->iflags;
                  D.32192 = (int) D.32191;
                  D.32193 = D.32192 & 4096;
                  if (D.32193 != 0) goto <D.32194>; else goto <D.32189>;
                  <D.32194>:
                  D.32125 = cmethod->klass;
                  D.32195 = mini_class_is_system_array (D.32125);
                  if (D.32195 != 0) goto <D.32196>; else goto <D.32189>;
                  <D.32196>:
                  D.32125 = cmethod->klass;
                  D.32197 = D.32125->rank;
                  array_rank = (int) D.32197;
                  fsig = mono_method_signature (cmethod);
                  goto <D.32190>;
                  <D.32189>:
                  fsig = mono_method_signature (cmethod);
                  if (fsig == 0B) goto <D.32198>; else goto <D.32199>;
                  <D.32198>:
                  D.32200 = mini_get_debug_options ();
                  D.32201 = D.32200->break_on_unverified;
                  if (D.32201 != 0) goto <D.32202>; else goto load_error;
                  <D.32202>:
                  raise (5);
                  <D.32199>:
                  D.32069 = BIT_FIELD_REF <*fsig, 64, 64>;
                  D.32070 = D.32069 & 128;
                  if (D.32070 != 0) goto <D.32203>; else goto <D.32204>;
                  <D.32203>:
                  {
                    struct MonoMethod * wrapper;

                    check_for_pending_exc.101 = check_for_pending_exc;
                    D.32206 = cfg->compile_aot;
                    D.32207 = (int) D.32206;
                    wrapper = mono_marshal_get_native_wrapper (cmethod, check_for_pending_exc.101, D.32207);
                    fsig = mono_method_signature (wrapper);
                  }
                  goto <D.32208>;
                  <D.32204>:
                  if (constrained_call != 0B) goto <D.32209>; else goto <D.32210>;
                  <D.32209>:
                  fsig = mono_method_signature (cmethod);
                  goto <D.32211>;
                  <D.32210>:
                  fsig = mono_method_get_signature_full (cmethod, image, token, generic_context);
                  <D.32211>:
                  <D.32208>:
                  <D.32190>:
                  cil_method.100 = cil_method;
                  mono_save_token_info (cfg, image, token, cil_method.100);
                  D.32212 = fsig->ret;
                  D.32213 = mono_type_is_void (D.32212);
                  if (D.32213 == 0) goto <D.32214>; else goto <D.32215>;
                  <D.32214>:
                  D.31664 = ip + 5;
                  if (D.31664 >= end) goto <D.32218>; else goto <D.32219>;
                  <D.32219>:
                  D.31664 = ip + 5;
                  D.32220 = *D.31664;
                  if (D.32220 != 38) goto <D.32221>; else goto <D.32217>;
                  <D.32221>:
                  D.31664 = ip + 5;
                  D.32220 = *D.31664;
                  if (D.32220 != 0) goto <D.32218>; else goto <D.32217>;
                  <D.32218>:
                  if (seq_point_locs == 0B) goto <D.32216>; else goto <D.32222>;
                  <D.32222>:
                  D.31664 = ip + 5;
                  D.32223 = (long int) D.31664;
                  D.30388 = header->code;
                  D.30933 = (long int) D.30388;
                  D.32224 = D.32223 - D.30933;
                  D.32225 = (long unsigned int) D.32224;
                  D.32226 = D.32225 / 64;
                  D.32227 = seq_point_locs->data[D.32226];
                  D.31664 = ip + 5;
                  D.32223 = (long int) D.31664;
                  D.30388 = header->code;
                  D.30933 = (long int) D.30388;
                  D.32224 = D.32223 - D.30933;
                  D.32228 = (unsigned int) D.32224;
                  D.32229 = D.32228 & 63;
                  D.32230 = D.32227 >> D.32229;
                  D.32231 = D.32230 & 1;
                  if (D.32231 == 0) goto <D.32216>; else goto <D.32217>;
                  <D.32216>:
                  need_seq_point = 1;
                  <D.32217>:
                  <D.32215>:
                  D.32062 = fsig->param_count;
                  D.32063 = (int) D.32062;
                  D.32064 = fsig->hasthis;
                  D.32065 = (int) D.32064;
                  n = D.32063 + D.32065;
                  D.32232 = mono_security_get_mode ();
                  if (D.32232 == 2) goto <D.32233>; else goto <D.32234>;
                  <D.32233>:
                  D.32235 = check_linkdemand (cfg, method, cmethod);
                  if (D.32235 != 0) goto <D.32236>; else goto <D.32237>;
                  <D.32236>:
                  D.30211 = cfg->method;
                  if (D.30211 != method) goto <D.32238>; else goto <D.32239>;
                  <D.32238>:
                  D.30183 = BIT_FIELD_REF <*method, 64, 256>;
                  D.30184 = D.30183 & 4467570830351532032;
                  if (D.30184 == 0) goto <D.32240>; else goto <D.32241>;
                  <D.32240>:
                  D.30322 = cfg->verbose_level;
                  if (D.30322 > 1) goto <D.32242>; else goto <D.32243>;
                  <D.32242>:
                  printf ("inline failed: %s\n", "linkdemand");
                  <D.32243>:
                  goto inline_failure;
                  <D.32241>:
                  <D.32239>:
                  <D.32237>:
                  D.30793 = cfg->exception_type;
                  if (D.30793 != 0) goto exception_exit; else goto <D.32244>;
                  <D.32244>:
                  <D.32234>:
                  D.32245 = BIT_FIELD_REF <*cmethod, 64, 256>;
                  D.32246 = D.32245 & 72057594037927936;
                  if (D.32246 != 0) goto <D.32247>; else goto <D.32248>;
                  <D.32247>:
                  D.30183 = BIT_FIELD_REF <*method, 64, 256>;
                  D.30184 = D.30183 & 4467570830351532032;
                  if (D.30184 != 576460752303423488) goto <D.32249>; else goto <D.32250>;
                  <D.32249>:
                  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 7769);
                  <D.32250>:
                  <D.32248>:
                }
              finally
                {
                  cil_method = {CLOBBER};
                }
            }
            <D.32099>:
            D.30278 = cfg->generic_sharing_context;
            if (D.30278 == 0B) goto <D.32251>; else goto <D.32252>;
            <D.32251>:
            if (cmethod != 0B) goto <D.32253>; else goto <D.32254>;
            <D.32253>:
            D.32125 = cmethod->klass;
            D.32255 = D.32125->generic_container;
            if (D.32255 != 0B) goto <D.32256>; else goto <D.32257>;
            <D.32256>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.32258>; else goto <D.32259>;
            <D.32258>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.32260>; else goto <D.32261>;
            <D.32260>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.32261>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.32259>:
            D.32262 = mini_get_debug_options ();
            D.32263 = D.32262->break_on_unverified;
            if (D.32263 != 0) goto <D.32264>; else goto unverified;
            <D.32264>:
            raise (5);
            <D.32257>:
            <D.32254>:
            <D.32252>:
            D.30278 = cfg->generic_sharing_context;
            if (D.30278 == 0B) goto <D.32265>; else goto <D.32266>;
            <D.32265>:
            if (cmethod != 0B) goto <D.32267>; else goto <D.32268>;
            <D.32267>:
            D.32269 = mono_method_check_context_used (cmethod);
            D.32270 = D.32269 != 0;
            D.32271 = (long int) D.32270;
            D.32272 = __builtin_expect (D.32271, 0);
            if (D.32272 != 0) goto <D.32273>; else goto <D.32274>;
            <D.32273>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7776, "!mono_method_check_context_used (cmethod)");
            <D.32274>:
            <D.32268>:
            <D.32266>:
            sp.71 = (long int) sp;
            stack_start.72 = (long int) stack_start;
            D.31013 = sp.71 - stack_start.72;
            D.31014 = D.31013 /[ex] 8;
            D.32275 = (long int) n;
            if (D.31014 < D.32275) goto <D.32276>; else goto <D.32277>;
            <D.32276>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.32278>; else goto <D.32279>;
            <D.32278>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.32280>; else goto <D.32281>;
            <D.32280>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.32281>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.32279>:
            D.32282 = mini_get_debug_options ();
            D.32283 = D.32282->break_on_unverified;
            if (D.32283 != 0) goto <D.32284>; else goto unverified;
            <D.32284>:
            raise (5);
            <D.32277>:
            D.31166 = (long unsigned int) n;
            D.31167 = D.31166 * 8;
            D.32285 = -D.31167;
            sp = sp + D.32285;
            if (constrained_call != 0B) goto <D.32286>; else goto <D.32287>;
            <D.32286>:
            D.32288 = mini_is_gsharedvt_klass (cfg, constrained_call);
            if (D.32288 != 0) goto <D.32289>; else goto <D.32290>;
            <D.32289>:
            D.32125 = cmethod->klass;
            D.32293 = mono_defaults.object_class;
            if (D.32125 != D.32293) goto <D.32294>; else goto <D.32291>;
            <D.32294>:
            D.32295 = BIT_FIELD_REF <*constrained_call, 64, 256>;
            D.32296 = D.32295 & 1152921504606846976;
            if (D.32296 != 0) goto <D.32297>; else goto <D.32291>;
            <D.32297>:
            D.32125 = cmethod->klass;
            D.32126 = BIT_FIELD_REF <*D.32125, 64, 256>;
            D.32127 = D.32126 & 1152921504606846976;
            if (D.32127 != 0) goto <D.32298>; else goto <D.32291>;
            <D.32298>:
            goto <D.32292>;
            <D.32291>:
            D.32125 = cmethod->klass;
            D.32301 = D.32125->image;
            D.32302 = mono_defaults.corlib;
            if (D.32301 != D.32302) goto <D.32303>; else goto <D.32299>;
            <D.32303>:
            D.32125 = cmethod->klass;
            D.32304 = D.32125->flags;
            D.32305 = D.32304 & 32;
            if (D.32305 == 0) goto <D.32306>; else goto <D.32299>;
            <D.32306>:
            D.32125 = cmethod->klass;
            D.32126 = BIT_FIELD_REF <*D.32125, 64, 256>;
            D.32127 = D.32126 & 1152921504606846976;
            if (D.32127 == 0) goto <D.32307>; else goto <D.32299>;
            <D.32307>:
            goto <D.32300>;
            <D.32299>:
            D.32125 = cmethod->klass;
            D.32293 = mono_defaults.object_class;
            if (D.32125 == D.32293) goto <D.32308>; else goto <D.32313>;
            <D.32313>:
            D.32125 = cmethod->klass;
            D.32304 = D.32125->flags;
            D.32305 = D.32304 & 32;
            if (D.32305 != 0) goto <D.32308>; else goto <D.32314>;
            <D.32314>:
            D.32125 = cmethod->klass;
            D.32126 = BIT_FIELD_REF <*D.32125, 64, 256>;
            D.32127 = D.32126 & 1152921504606846976;
            if (D.32127 == 0) goto <D.32315>; else goto <D.32309>;
            <D.32315>:
            D.32125 = cmethod->klass;
            D.32301 = D.32125->image;
            D.32302 = mono_defaults.corlib;
            if (D.32301 != D.32302) goto <D.32308>; else goto <D.32309>;
            <D.32308>:
            D.32212 = fsig->ret;
            D.32316 = mono_type_is_void (D.32212);
            if (D.32316 != 0) goto <D.32310>; else goto <D.32317>;
            <D.32317>:
            D.32212 = fsig->ret;
            D.32318 = BIT_FIELD_REF <*D.32212, 64, 64>;
            D.32319 = D.32318 & 8589934592;
            if (D.32319 == 0) goto <D.32320>; else goto <D.32311>;
            <D.32320>:
            D.32212 = fsig->ret;
            D.32321 = D.32212->type;
            D.32322 = D.32321 + 254;
            if (D.32322 <= 11) goto <D.32310>; else goto <D.32323>;
            <D.32323>:
            D.32212 = fsig->ret;
            D.32321 = D.32212->type;
            D.32324 = D.32321 + 232;
            if (D.32324 <= 1) goto <D.32310>; else goto <D.32311>;
            <D.32311>:
            D.32212 = fsig->ret;
            D.32325 = mono_type_is_reference (D.32212);
            if (D.32325 != 0) goto <D.32310>; else goto <D.32326>;
            <D.32326>:
            D.32212 = fsig->ret;
            D.32327 = mini_is_gsharedvt_type (cfg, D.32212);
            if (D.32327 != 0) goto <D.32310>; else goto <D.32309>;
            <D.32310>:
            D.32062 = fsig->param_count;
            if (D.32062 == 0) goto <D.32312>; else goto <D.32328>;
            <D.32328>:
            D.32069 = BIT_FIELD_REF <*fsig, 64, 64>;
            D.32329 = D.32069 & 18446462598732841472;
            if (D.32329 == 281474976710656) goto <D.32312>; else goto <D.32330>;
            <D.32330>:
            D.32062 = fsig->param_count;
            if (D.32062 == 1) goto <D.32331>; else goto <D.32309>;
            <D.32331>:
            D.32332 = fsig->params[0];
            D.32333 = mono_type_is_reference (D.32332);
            if (D.32333 != 0) goto <D.32312>; else goto <D.32334>;
            <D.32334>:
            D.32332 = fsig->params[0];
            D.32335 = mini_is_gsharedvt_type (cfg, D.32332);
            if (D.32335 != 0) goto <D.32312>; else goto <D.32309>;
            <D.32312>:
            {
              struct MonoInst * args[16];

              try
                {
                  D.31240 = *sp;
                  args[0] = D.31240;
                  D.32336 = mono_method_check_context_used (cmethod);
                  if (D.32336 != 0) goto <D.32337>; else goto <D.32338>;
                  <D.32337>:
                  D.32339 = mono_method_check_context_used (cmethod);
                  D.32340 = emit_get_rgctx_method (cfg, D.32339, cmethod, 5);
                  args[1] = D.32340;
                  goto <D.32341>;
                  <D.32338>:
                  D.30241 = cfg->mempool;
                  D.32342 = mono_mempool_alloc (D.30241, 80);
                  args[1] = D.32342;
                  D.32343 = args[1];
                  D.32343 = args[1];
                  D.32343->data.op[1].const_val = 0;
                  D.32344 = D.32343->data.op[1].const_val;
                  D.32343->data.op[0].const_val = D.32344;
                  D.32343 = args[1];
                  D.32343 = args[1];
                  D.32343->prev = 0B;
                  D.32345 = D.32343->prev;
                  D.32343->next = D.32345;
                  D.32343 = args[1];
                  D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
                  D.30635 = D.30634 & 33554432;
                  if (D.30635 != 0) goto <D.32347>; else goto <D.32348>;
                  <D.32347>:
                  iftmp.102 = 732;
                  goto <D.32349>;
                  <D.32348>:
                  iftmp.102 = 363;
                  <D.32349>:
                  D.32343->opcode = iftmp.102;
                  D.32343 = args[1];
                  D.32343->flags = 0;
                  D.32343 = args[1];
                  D.32343->type = 0;
                  D.32343 = args[1];
                  D.32343->dreg = -1;
                  D.32343 = args[1];
                  D.32343 = args[1];
                  D.32343 = args[1];
                  D.32343->sreg3 = -1;
                  D.32350 = D.32343->sreg3;
                  D.32343->sreg2 = D.32350;
                  D.32351 = D.32343->sreg2;
                  D.32343->sreg1 = D.32351;
                  D.32343 = args[1];
                  D.30461 = cfg->ip;
                  D.32343->cil_code = D.30461;
                  D.32343 = args[1];
                  D.32343->data.op[0].p = cmethod;
                  D.32343 = args[1];
                  D.32343->data.op[1].src = 6B;
                  D.32343 = args[1];
                  D.32343->type = 3;
                  D.32343 = args[1];
                  D.32352 = alloc_dreg (cfg, 3);
                  D.32353 = (int) D.32352;
                  D.32343->dreg = D.32353;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.32354>; else goto <D.32355>;
                  <D.32354>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.32343 = args[1];
                  D.30490->next = D.32343;
                  D.32343 = args[1];
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.32343->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  D.32343 = args[1];
                  bblock.106->last_ins = D.32343;
                  goto <D.32356>;
                  <D.32355>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  D.32343 = args[1];
                  bblock.106->last_ins = D.32343;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.32356>:
                  <D.32341>:
                  D.32357 = mono_class_check_context_used (constrained_call);
                  D.32358 = emit_get_rgctx_klass (cfg, D.32357, constrained_call, 1);
                  args[2] = D.32358;
                  D.32069 = BIT_FIELD_REF <*fsig, 64, 64>;
                  D.32361 = D.32069 & 512;
                  if (D.32361 != 0) goto <D.32362>; else goto <D.32359>;
                  <D.32362>:
                  D.32062 = fsig->param_count;
                  if (D.32062 != 0) goto <D.32363>; else goto <D.32359>;
                  <D.32363>:
                  D.30241 = cfg->mempool;
                  ins = mono_mempool_alloc (D.30241, 80);
                  ins->data.op[1].const_val = 0;
                  D.30457 = ins->data.op[1].const_val;
                  ins->data.op[0].const_val = D.30457;
                  ins->prev = 0B;
                  D.30458 = ins->prev;
                  ins->next = D.30458;
                  ins->opcode = 339;
                  ins->flags = 0;
                  ins->type = 0;
                  ins->dreg = -1;
                  ins->sreg3 = -1;
                  D.30459 = ins->sreg3;
                  ins->sreg2 = D.30459;
                  D.30460 = ins->sreg2;
                  ins->sreg1 = D.30460;
                  D.30461 = cfg->ip;
                  ins->cil_code = D.30461;
                  D.32364 = alloc_preg (cfg);
                  D.32365 = (int) D.32364;
                  ins->dreg = D.32365;
                  D.32062 = fsig->param_count;
                  D.32366 = (long unsigned int) D.32062;
                  D.32367 = D.32366 * 8;
                  D.32368 = (long int) D.32367;
                  ins->data.op[1].const_val = D.32368;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.32369>; else goto <D.32370>;
                  <D.32369>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.30490->next = ins;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  ins->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  bblock.106->last_ins = ins;
                  goto <D.32371>;
                  <D.32370>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  bblock.106->last_ins = ins;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.32371>:
                  args[4] = ins;
                  D.32332 = fsig->params[0];
                  D.32372 = mini_is_gsharedvt_type (cfg, D.32332);
                  if (D.32372 != 0) goto <D.32373>; else goto <D.32374>;
                  <D.32373>:
                  {
                    int addr_reg;

                    D.32332 = fsig->params[0];
                    D.32375 = mono_class_from_mono_type (D.32332);
                    D.32376 = emit_get_gsharedvt_info_klass (cfg, D.32375, 19);
                    args[3] = D.32376;
                    {
                      struct MonoInst * var;

                      D.32378 = sp + 8;
                      D.32379 = *D.32378;
                      D.32380 = D.32379->dreg;
                      D.32381 = (unsigned int) D.32380;
                      D.31341 = cfg->vreg_to_inst_len;
                      if (D.32381 < D.31341) goto <D.32382>; else goto <D.32383>;
                      <D.32382>:
                      D.31344 = cfg->vreg_to_inst;
                      D.32378 = sp + 8;
                      D.32379 = *D.32378;
                      D.32380 = D.32379->dreg;
                      D.32384 = (long unsigned int) D.32380;
                      D.32385 = D.32384 * 8;
                      D.32386 = D.31344 + D.32385;
                      iftmp.103 = *D.32386;
                      goto <D.32387>;
                      <D.32383>:
                      iftmp.103 = 0B;
                      <D.32387>:
                      var = iftmp.103;
                      if (var == 0B) goto <D.32388>; else goto <D.32389>;
                      <D.32388>:
                      D.32332 = fsig->params[0];
                      D.32378 = sp + 8;
                      D.32379 = *D.32378;
                      D.32380 = D.32379->dreg;
                      var = mono_compile_create_var_for_vreg (cfg, D.32332, 329, D.32380);
                      <D.32389>:
                      D.30241 = cfg->mempool;
                      ins = mono_mempool_alloc (D.30241, 80);
                      ins->data.op[1].const_val = 0;
                      D.30457 = ins->data.op[1].const_val;
                      ins->data.op[0].const_val = D.30457;
                      ins->prev = 0B;
                      D.30458 = ins->prev;
                      ins->next = D.30458;
                      ins->opcode = 314;
                      ins->flags = 0;
                      ins->type = 0;
                      ins->dreg = -1;
                      ins->sreg3 = -1;
                      D.30459 = ins->sreg3;
                      ins->sreg2 = D.30459;
                      D.30460 = ins->sreg2;
                      ins->sreg1 = D.30460;
                      D.30461 = cfg->ip;
                      ins->cil_code = D.30461;
                      ins->data.op[0].p = var;
                      D.32390 = var->flags;
                      D.32391 = D.32390 | 16;
                      var->flags = D.32391;
                      ins->type = 5;
                      D.32392 = var->klass;
                      ins->klass = D.32392;
                      D.32393 = alloc_dreg (cfg, 5);
                      D.32394 = (int) D.32393;
                      ins->dreg = D.32394;
                      cfg->has_indirection = 1;
                      D.30389 = cfg->gsharedvt;
                      D.31326 = D.30389 != 0;
                      D.31327 = (long int) D.31326;
                      D.31328 = __builtin_expect (D.31327, 0);
                      if (D.31328 != 0) goto <D.32395>; else goto <D.32396>;
                      <D.32395>:
                      D.32397 = var->data.op[1].vtype;
                      D.32398 = mini_is_gsharedvt_variable_type (cfg, D.32397);
                      if (D.32398 != 0) goto <D.32399>; else goto <D.32400>;
                      <D.32399>:
                      handle_gsharedvt_ldaddr (cfg);
                      <D.32400>:
                      <D.32396>:
                      if (0 != 0) goto <D.32401>; else goto <D.32402>;
                      <D.32401>:
                      {
                        struct MonoInst * var1;
                        struct MonoInst * var2;

                        D.32404 = var->dreg;
                        D.32405 = D.32404 + 1;
                        D.32406 = (unsigned int) D.32405;
                        D.31341 = cfg->vreg_to_inst_len;
                        if (D.32406 < D.31341) goto <D.32407>; else goto <D.32408>;
                        <D.32407>:
                        D.31344 = cfg->vreg_to_inst;
                        D.32404 = var->dreg;
                        D.32409 = (sizetype) D.32404;
                        D.32410 = D.32409 + 1;
                        D.32411 = D.32410 * 8;
                        D.32412 = D.31344 + D.32411;
                        iftmp.104 = *D.32412;
                        goto <D.32413>;
                        <D.32408>:
                        iftmp.104 = 0B;
                        <D.32413>:
                        var1 = iftmp.104;
                        D.32404 = var->dreg;
                        D.32415 = D.32404 + 2;
                        D.32416 = (unsigned int) D.32415;
                        D.31341 = cfg->vreg_to_inst_len;
                        if (D.32416 < D.31341) goto <D.32417>; else goto <D.32418>;
                        <D.32417>:
                        D.31344 = cfg->vreg_to_inst;
                        D.32404 = var->dreg;
                        D.32409 = (sizetype) D.32404;
                        D.32419 = D.32409 + 2;
                        D.32420 = D.32419 * 8;
                        D.32421 = D.31344 + D.32420;
                        iftmp.105 = *D.32421;
                        goto <D.32422>;
                        <D.32418>:
                        iftmp.105 = 0B;
                        <D.32422>:
                        var2 = iftmp.105;
                        D.32423 = var1 == 0B;
                        D.32424 = (long int) D.32423;
                        D.32425 = __builtin_expect (D.32424, 0);
                        if (D.32425 != 0) goto <D.32426>; else goto <D.32427>;
                        <D.32426>:
                        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7827, "var1");
                        <D.32427>:
                        D.32428 = var2 == 0B;
                        D.32429 = (long int) D.32428;
                        D.32430 = __builtin_expect (D.32429, 0);
                        if (D.32430 != 0) goto <D.32431>; else goto <D.32432>;
                        <D.32431>:
                        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7827, "var2");
                        <D.32432>:
                        D.32433 = var1->flags;
                        D.32434 = D.32433 | 16;
                        var1->flags = D.32434;
                        D.32435 = var2->flags;
                        D.32436 = D.32435 | 16;
                        var2->flags = D.32436;
                      }
                      <D.32402>:
                    }
                    bblock.106 = cfg->cbb;
                    D.30490 = bblock.106->last_ins;
                    if (D.30490 != 0B) goto <D.32437>; else goto <D.32438>;
                    <D.32437>:
                    bblock.106 = cfg->cbb;
                    D.30490 = bblock.106->last_ins;
                    D.30490->next = ins;
                    bblock.106 = cfg->cbb;
                    D.30490 = bblock.106->last_ins;
                    ins->prev = D.30490;
                    bblock.106 = cfg->cbb;
                    bblock.106->last_ins = ins;
                    goto <D.32439>;
                    <D.32438>:
                    bblock.106 = cfg->cbb;
                    bblock.106 = cfg->cbb;
                    bblock.106->last_ins = ins;
                    D.30490 = bblock.106->last_ins;
                    bblock.106->code = D.30490;
                    <D.32439>:
                    addr_reg = ins->dreg;
                    D.30241 = cfg->mempool;
                    ins = mono_mempool_alloc (D.30241, 80);
                    ins->data.op[1].const_val = 0;
                    D.30457 = ins->data.op[1].const_val;
                    ins->data.op[0].const_val = D.30457;
                    ins->prev = 0B;
                    D.30458 = ins->prev;
                    ins->next = D.30458;
                    ins->opcode = 374;
                    ins->flags = 0;
                    ins->type = 0;
                    ins->dreg = -1;
                    ins->sreg3 = -1;
                    D.30459 = ins->sreg3;
                    ins->sreg2 = D.30459;
                    D.30460 = ins->sreg2;
                    ins->sreg1 = D.30460;
                    D.30461 = cfg->ip;
                    ins->cil_code = D.30461;
                    ins->sreg1 = addr_reg;
                    D.32440 = args[4];
                    D.32441 = D.32440->dreg;
                    ins->dreg = D.32441;
                    ins->data.op[0].const_val = 0;
                    bblock.106 = cfg->cbb;
                    D.30490 = bblock.106->last_ins;
                    if (D.30490 != 0B) goto <D.32442>; else goto <D.32443>;
                    <D.32442>:
                    bblock.106 = cfg->cbb;
                    D.30490 = bblock.106->last_ins;
                    D.30490->next = ins;
                    bblock.106 = cfg->cbb;
                    D.30490 = bblock.106->last_ins;
                    ins->prev = D.30490;
                    bblock.106 = cfg->cbb;
                    bblock.106->last_ins = ins;
                    goto <D.32444>;
                    <D.32443>:
                    bblock.106 = cfg->cbb;
                    bblock.106 = cfg->cbb;
                    bblock.106->last_ins = ins;
                    D.30490 = bblock.106->last_ins;
                    bblock.106->code = D.30490;
                    <D.32444>:
                  }
                  goto <D.32445>;
                  <D.32374>:
                  D.30241 = cfg->mempool;
                  D.32446 = mono_mempool_alloc (D.30241, 80);
                  args[3] = D.32446;
                  D.32447 = args[3];
                  D.32447 = args[3];
                  D.32447->data.op[1].const_val = 0;
                  D.32448 = D.32447->data.op[1].const_val;
                  D.32447->data.op[0].const_val = D.32448;
                  D.32447 = args[3];
                  D.32447 = args[3];
                  D.32447->prev = 0B;
                  D.32449 = D.32447->prev;
                  D.32447->next = D.32449;
                  D.32447 = args[3];
                  D.32447->opcode = 362;
                  D.32447 = args[3];
                  D.32447->flags = 0;
                  D.32447 = args[3];
                  D.32447->type = 0;
                  D.32447 = args[3];
                  D.32447->dreg = -1;
                  D.32447 = args[3];
                  D.32447 = args[3];
                  D.32447 = args[3];
                  D.32447->sreg3 = -1;
                  D.32450 = D.32447->sreg3;
                  D.32447->sreg2 = D.32450;
                  D.32451 = D.32447->sreg2;
                  D.32447->sreg1 = D.32451;
                  D.32447 = args[3];
                  D.30461 = cfg->ip;
                  D.32447->cil_code = D.30461;
                  D.32447 = args[3];
                  D.32447->data.op[0].const_val = 0;
                  D.32447 = args[3];
                  D.32447->type = 1;
                  D.32447 = args[3];
                  D.32452 = alloc_dreg (cfg, 1);
                  D.32453 = (int) D.32452;
                  D.32447->dreg = D.32453;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.32454>; else goto <D.32455>;
                  <D.32454>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.32447 = args[3];
                  D.30490->next = D.32447;
                  D.32447 = args[3];
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.32447->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  D.32447 = args[3];
                  bblock.106->last_ins = D.32447;
                  goto <D.32456>;
                  <D.32455>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  D.32447 = args[3];
                  bblock.106->last_ins = D.32447;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.32456>:
                  D.30241 = cfg->mempool;
                  ins = mono_mempool_alloc (D.30241, 80);
                  ins->data.op[1].const_val = 0;
                  D.30457 = ins->data.op[1].const_val;
                  ins->data.op[0].const_val = D.30457;
                  ins->prev = 0B;
                  D.30458 = ins->prev;
                  ins->next = D.30458;
                  ins->opcode = 374;
                  ins->flags = 0;
                  ins->type = 0;
                  ins->dreg = -1;
                  ins->sreg3 = -1;
                  D.30459 = ins->sreg3;
                  ins->sreg2 = D.30459;
                  D.30460 = ins->sreg2;
                  ins->sreg1 = D.30460;
                  D.30461 = cfg->ip;
                  ins->cil_code = D.30461;
                  D.32378 = sp + 8;
                  D.32379 = *D.32378;
                  D.32380 = D.32379->dreg;
                  ins->sreg1 = D.32380;
                  D.32440 = args[4];
                  D.32441 = D.32440->dreg;
                  ins->dreg = D.32441;
                  ins->data.op[0].const_val = 0;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.32457>; else goto <D.32458>;
                  <D.32457>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.30490->next = ins;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  ins->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  bblock.106->last_ins = ins;
                  goto <D.32459>;
                  <D.32458>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  bblock.106->last_ins = ins;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.32459>:
                  <D.32445>:
                  goto <D.32360>;
                  <D.32359>:
                  D.30241 = cfg->mempool;
                  D.32460 = mono_mempool_alloc (D.30241, 80);
                  args[3] = D.32460;
                  D.32447 = args[3];
                  D.32447 = args[3];
                  D.32447->data.op[1].const_val = 0;
                  D.32448 = D.32447->data.op[1].const_val;
                  D.32447->data.op[0].const_val = D.32448;
                  D.32447 = args[3];
                  D.32447 = args[3];
                  D.32447->prev = 0B;
                  D.32449 = D.32447->prev;
                  D.32447->next = D.32449;
                  D.32447 = args[3];
                  D.32447->opcode = 362;
                  D.32447 = args[3];
                  D.32447->flags = 0;
                  D.32447 = args[3];
                  D.32447->type = 0;
                  D.32447 = args[3];
                  D.32447->dreg = -1;
                  D.32447 = args[3];
                  D.32447 = args[3];
                  D.32447 = args[3];
                  D.32447->sreg3 = -1;
                  D.32450 = D.32447->sreg3;
                  D.32447->sreg2 = D.32450;
                  D.32451 = D.32447->sreg2;
                  D.32447->sreg1 = D.32451;
                  D.32447 = args[3];
                  D.30461 = cfg->ip;
                  D.32447->cil_code = D.30461;
                  D.32447 = args[3];
                  D.32447->data.op[0].const_val = 0;
                  D.32447 = args[3];
                  D.32447->type = 1;
                  D.32447 = args[3];
                  D.32461 = alloc_dreg (cfg, 1);
                  D.32462 = (int) D.32461;
                  D.32447->dreg = D.32462;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.32463>; else goto <D.32464>;
                  <D.32463>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.32447 = args[3];
                  D.30490->next = D.32447;
                  D.32447 = args[3];
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.32447->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  D.32447 = args[3];
                  bblock.106->last_ins = D.32447;
                  goto <D.32465>;
                  <D.32464>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  D.32447 = args[3];
                  bblock.106->last_ins = D.32447;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.32465>:
                  D.30241 = cfg->mempool;
                  D.32466 = mono_mempool_alloc (D.30241, 80);
                  args[4] = D.32466;
                  D.32440 = args[4];
                  D.32440 = args[4];
                  D.32440->data.op[1].const_val = 0;
                  D.32467 = D.32440->data.op[1].const_val;
                  D.32440->data.op[0].const_val = D.32467;
                  D.32440 = args[4];
                  D.32440 = args[4];
                  D.32440->prev = 0B;
                  D.32468 = D.32440->prev;
                  D.32440->next = D.32468;
                  D.32440 = args[4];
                  D.32440->opcode = 362;
                  D.32440 = args[4];
                  D.32440->flags = 0;
                  D.32440 = args[4];
                  D.32440->type = 0;
                  D.32440 = args[4];
                  D.32440->dreg = -1;
                  D.32440 = args[4];
                  D.32440 = args[4];
                  D.32440 = args[4];
                  D.32440->sreg3 = -1;
                  D.32469 = D.32440->sreg3;
                  D.32440->sreg2 = D.32469;
                  D.32470 = D.32440->sreg2;
                  D.32440->sreg1 = D.32470;
                  D.32440 = args[4];
                  D.30461 = cfg->ip;
                  D.32440->cil_code = D.30461;
                  D.32440 = args[4];
                  D.32440->data.op[0].const_val = 0;
                  D.32440 = args[4];
                  D.32440->type = 1;
                  D.32440 = args[4];
                  D.32471 = alloc_dreg (cfg, 1);
                  D.32472 = (int) D.32471;
                  D.32440->dreg = D.32472;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.32473>; else goto <D.32474>;
                  <D.32473>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.32440 = args[4];
                  D.30490->next = D.32440;
                  D.32440 = args[4];
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.32440->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  D.32440 = args[4];
                  bblock.106->last_ins = D.32440;
                  goto <D.32475>;
                  <D.32474>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  D.32440 = args[4];
                  bblock.106->last_ins = D.32440;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.32475>:
                  <D.32360>:
                  ins = mono_emit_jit_icall (cfg, mono_gsharedvt_constrained_call, &args);
                  emit_widen = 0;
                  D.32212 = fsig->ret;
                  D.32476 = mini_is_gsharedvt_type (cfg, D.32212);
                  if (D.32476 != 0) goto <D.32477>; else goto <D.32478>;
                  <D.32477>:
                  D.32212 = fsig->ret;
                  D.32479 = mono_class_from_mono_type (D.32212);
                  ins = handle_unbox_gsharedvt (cfg, D.32479, ins, &bblock);
                  goto <D.32480>;
                  <D.32478>:
                  D.32212 = fsig->ret;
                  D.32318 = BIT_FIELD_REF <*D.32212, 64, 64>;
                  D.32319 = D.32318 & 8589934592;
                  if (D.32319 == 0) goto <D.32483>; else goto <D.32484>;
                  <D.32483>:
                  D.32212 = fsig->ret;
                  D.32321 = D.32212->type;
                  D.32322 = D.32321 + 254;
                  if (D.32322 <= 11) goto <D.32481>; else goto <D.32485>;
                  <D.32485>:
                  D.32212 = fsig->ret;
                  D.32321 = D.32212->type;
                  D.32324 = D.32321 + 232;
                  if (D.32324 <= 1) goto <D.32481>; else goto <D.32482>;
                  <D.32481>:
                  {
                    struct MonoInst * add;

                    D.30241 = cfg->mempool;
                    add = mono_mempool_alloc (D.30241, 80);
                    add->data.op[1].const_val = 0;
                    D.32486 = add->data.op[1].const_val;
                    add->data.op[0].const_val = D.32486;
                    add->prev = 0B;
                    D.32487 = add->prev;
                    add->next = D.32487;
                    add->opcode = 429;
                    add->flags = 0;
                    add->type = 0;
                    add->dreg = -1;
                    add->sreg3 = -1;
                    D.32488 = add->sreg3;
                    add->sreg2 = D.32488;
                    D.32489 = add->sreg2;
                    add->sreg1 = D.32489;
                    D.30461 = cfg->ip;
                    add->cil_code = D.30461;
                    D.32490 = alloc_dreg (cfg, 5);
                    D.32491 = (int) D.32490;
                    add->dreg = D.32491;
                    D.30654 = ins->dreg;
                    add->sreg1 = D.30654;
                    add->data.op[1].const_val = 16;
                    bblock.106 = cfg->cbb;
                    D.30490 = bblock.106->last_ins;
                    if (D.30490 != 0B) goto <D.32492>; else goto <D.32493>;
                    <D.32492>:
                    bblock.106 = cfg->cbb;
                    D.30490 = bblock.106->last_ins;
                    D.30490->next = add;
                    bblock.106 = cfg->cbb;
                    D.30490 = bblock.106->last_ins;
                    add->prev = D.30490;
                    bblock.106 = cfg->cbb;
                    bblock.106->last_ins = add;
                    goto <D.32494>;
                    <D.32493>:
                    bblock.106 = cfg->cbb;
                    bblock.106 = cfg->cbb;
                    bblock.106->last_ins = add;
                    D.30490 = bblock.106->last_ins;
                    bblock.106->code = D.30490;
                    <D.32494>:
                    D.30241 = cfg->mempool;
                    ins = mono_mempool_alloc (D.30241, 80);
                    ins->data.op[1].const_val = 0;
                    D.30457 = ins->data.op[1].const_val;
                    ins->data.op[0].const_val = D.30457;
                    ins->prev = 0B;
                    D.30458 = ins->prev;
                    ins->next = D.30458;
                    D.32212 = fsig->ret;
                    D.32495 = mono_type_to_load_membase (cfg, D.32212);
                    D.32496 = (short unsigned int) D.32495;
                    ins->opcode = D.32496;
                    ins->flags = 0;
                    ins->type = 0;
                    ins->dreg = -1;
                    ins->sreg3 = -1;
                    D.30459 = ins->sreg3;
                    ins->sreg2 = D.30459;
                    D.30460 = ins->sreg2;
                    ins->sreg1 = D.30460;
                    D.30461 = cfg->ip;
                    ins->cil_code = D.30461;
                    ins->dreg = 0;
                    D.32497 = add->dreg;
                    ins->sreg1 = D.32497;
                    ins->data.op[0].const_val = 0;
                    ins->type = 1;
                    D.32212 = fsig->ret;
                    type_to_eval_stack_type (cfg, D.32212, ins);
                    D.30988 = ins->type;
                    D.30989 = (<unnamed type>) D.30988;
                    D.32498 = alloc_dreg (cfg, D.30989);
                    D.32499 = (int) D.32498;
                    ins->dreg = D.32499;
                    bblock.106 = cfg->cbb;
                    D.30490 = bblock.106->last_ins;
                    if (D.30490 != 0B) goto <D.32500>; else goto <D.32501>;
                    <D.32500>:
                    bblock.106 = cfg->cbb;
                    D.30490 = bblock.106->last_ins;
                    D.30490->next = ins;
                    bblock.106 = cfg->cbb;
                    D.30490 = bblock.106->last_ins;
                    ins->prev = D.30490;
                    bblock.106 = cfg->cbb;
                    bblock.106->last_ins = ins;
                    goto <D.32502>;
                    <D.32501>:
                    bblock.106 = cfg->cbb;
                    bblock.106 = cfg->cbb;
                    bblock.106->last_ins = ins;
                    D.30490 = bblock.106->last_ins;
                    bblock.106->code = D.30490;
                    <D.32502>:
                  }
                  <D.32482>:
                  <D.32484>:
                  <D.32480>:
                  goto call_end;
                }
              finally
                {
                  args = {CLOBBER};
                }
            }
            <D.32309>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.32503>; else goto <D.32504>;
            <D.32503>:
            D.30178 = method->klass;
            D.31934 = D.30178->name_space;
            D.30178 = method->klass;
            D.31935 = D.30178->name;
            D.31936 = method->name;
            D.31937 = method->signature;
            D.31938 = D.31937->param_count;
            D.31939 = (int) D.31938;
            D.31121 = *ip;
            D.31122 = (int) D.31121;
            D.32505 = mono_opcode_name (D.31122);
            D.32506 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.31934, D.31935, D.31936, D.31939, D.32505, "method-to-ir.c", 7857);
            cfg->exception_message = D.32506;
            D.30322 = cfg->verbose_level;
            if (D.30322 > 1) goto <D.32507>; else goto <D.32508>;
            <D.32507>:
            D.31944 = cfg->exception_message;
            printf ("%s\n", D.31944);
            <D.32508>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.32504>:
            <D.32300>:
            <D.32292>:
            <D.32290>:
            D.32295 = BIT_FIELD_REF <*constrained_call, 64, 256>;
            D.32296 = D.32295 & 1152921504606846976;
            if (D.32296 != 0) goto <D.32512>; else goto <D.32509>;
            <D.32512>:
            D.32125 = cmethod->klass;
            D.32293 = mono_defaults.object_class;
            if (D.32125 == D.32293) goto <D.32510>; else goto <D.32513>;
            <D.32513>:
            D.32125 = cmethod->klass;
            D.32514 = mono_defaults.enum_class;
            D.32515 = D.32514->parent;
            if (D.32125 == D.32515) goto <D.32510>; else goto <D.32516>;
            <D.32516>:
            D.32125 = cmethod->klass;
            D.32514 = mono_defaults.enum_class;
            if (D.32125 == D.32514) goto <D.32510>; else goto <D.32509>;
            <D.32510>:
            D.30241 = cfg->mempool;
            ins = mono_mempool_alloc (D.30241, 80);
            ins->data.op[1].const_val = 0;
            D.30457 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.30457;
            ins->prev = 0B;
            D.30458 = ins->prev;
            ins->next = D.30458;
            D.32517 = &constrained_call->byval_arg;
            D.32518 = mono_type_to_load_membase (cfg, D.32517);
            D.32519 = (short unsigned int) D.32518;
            ins->opcode = D.32519;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.30459 = ins->sreg3;
            ins->sreg2 = D.30459;
            D.30460 = ins->sreg2;
            ins->sreg1 = D.30460;
            D.30461 = cfg->ip;
            ins->cil_code = D.30461;
            ins->dreg = 0;
            D.31240 = *sp;
            D.31422 = D.31240->dreg;
            ins->sreg1 = D.31422;
            ins->data.op[0].const_val = 0;
            ins->type = 1;
            D.32517 = &constrained_call->byval_arg;
            type_to_eval_stack_type (cfg, D.32517, ins);
            D.30988 = ins->type;
            D.30989 = (<unnamed type>) D.30988;
            D.32520 = alloc_dreg (cfg, D.30989);
            D.32521 = (int) D.32520;
            ins->dreg = D.32521;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.32522>; else goto <D.32523>;
            <D.32522>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = ins;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            ins->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            goto <D.32524>;
            <D.32523>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.32524>:
            ins->klass = constrained_call;
            D.32525 = mono_class_check_context_used (constrained_call);
            D.32526 = handle_box (cfg, ins, constrained_call, D.32525, &bblock);
            *sp = D.32526;
            D.30793 = cfg->exception_type;
            if (D.30793 != 0) goto exception_exit; else goto <D.32527>;
            <D.32527>:
            goto <D.32511>;
            <D.32509>:
            D.32295 = BIT_FIELD_REF <*constrained_call, 64, 256>;
            D.32296 = D.32295 & 1152921504606846976;
            if (D.32296 == 0) goto <D.32528>; else goto <D.32529>;
            <D.32528>:
            {
              int dreg;

              D.32530 = alloc_ireg_ref (cfg);
              dreg = (int) D.32530;
              D.30241 = cfg->mempool;
              ins = mono_mempool_alloc (D.30241, 80);
              ins->data.op[1].const_val = 0;
              D.30457 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.30457;
              ins->prev = 0B;
              D.30458 = ins->prev;
              ins->next = D.30458;
              ins->opcode = 388;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.30459 = ins->sreg3;
              ins->sreg2 = D.30459;
              D.30460 = ins->sreg2;
              ins->sreg1 = D.30460;
              D.30461 = cfg->ip;
              ins->cil_code = D.30461;
              ins->dreg = dreg;
              D.31240 = *sp;
              D.31422 = D.31240->dreg;
              ins->sreg1 = D.31422;
              ins->data.op[0].const_val = 0;
              ins->type = 1;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.32531>; else goto <D.32532>;
              <D.32531>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = ins;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              ins->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              goto <D.32533>;
              <D.32532>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.32533>:
              ins->type = 6;
              *sp = ins;
            }
            goto <D.32534>;
            <D.32529>:
            D.32125 = cmethod->klass;
            D.32126 = BIT_FIELD_REF <*D.32125, 64, 256>;
            D.32127 = D.32126 & 1152921504606846976;
            if (D.32127 != 0) goto <D.32535>; else goto <D.32536>;
            <D.32535>:
            goto <D.32537>;
            <D.32536>:
            {
              int ioffset;
              int slot;

              mono_class_setup_vtable (constrained_call);
              if (constrained_call == 0B) goto <D.32538>; else goto <D.32540>;
              <D.32540>:
              D.32541 = constrained_call->exception_type;
              if (D.32541 != 0) goto <D.32538>; else goto <D.32539>;
              <D.32538>:
              cfg->exception_ptr = constrained_call;
              D.32542 = mini_get_debug_options ();
              D.32543 = D.32542->break_on_unverified;
              if (D.32543 != 0) goto <D.32544>; else goto load_error;
              <D.32544>:
              raise (5);
              <D.32539>:
              D.32125 = cmethod->klass;
              ioffset = mono_class_interface_offset (constrained_call, D.32125);
              if (ioffset == -1) goto <D.32545>; else goto <D.32546>;
              <D.32545>:
              D.32547 = mini_get_debug_options ();
              D.32548 = D.32547->break_on_unverified;
              if (D.32548 != 0) goto <D.32549>; else goto <D.32550>;
              <D.32549>:
              raise (5);
              goto <D.32551>;
              <D.32550>:
              cfg->exception_ptr = constrained_call;
              goto load_error;
              <D.32551>:
              <D.32546>:
              slot = mono_method_get_vtable_slot (cmethod);
              if (slot == -1) goto <D.32552>; else goto <D.32553>;
              <D.32552>:
              D.32554 = mini_get_debug_options ();
              D.32555 = D.32554->break_on_unverified;
              if (D.32555 != 0) goto <D.32556>; else goto <D.32557>;
              <D.32556>:
              raise (5);
              goto <D.32558>;
              <D.32557>:
              D.32125 = cmethod->klass;
              cfg->exception_ptr = D.32125;
              goto load_error;
              <D.32558>:
              <D.32553>:
              D.32559 = constrained_call->vtable;
              D.32560 = ioffset + slot;
              D.32561 = (long unsigned int) D.32560;
              D.32562 = D.32561 * 8;
              D.32563 = D.32559 + D.32562;
              cmethod = *D.32563;
              D.32125 = cmethod->klass;
              D.32514 = mono_defaults.enum_class;
              if (D.32125 == D.32514) goto <D.32564>; else goto <D.32565>;
              <D.32564>:
              D.30241 = cfg->mempool;
              ins = mono_mempool_alloc (D.30241, 80);
              ins->data.op[1].const_val = 0;
              D.30457 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.30457;
              ins->prev = 0B;
              D.30458 = ins->prev;
              ins->next = D.30458;
              D.32517 = &constrained_call->byval_arg;
              D.32566 = mono_type_to_load_membase (cfg, D.32517);
              D.32567 = (short unsigned int) D.32566;
              ins->opcode = D.32567;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.30459 = ins->sreg3;
              ins->sreg2 = D.30459;
              D.30460 = ins->sreg2;
              ins->sreg1 = D.30460;
              D.30461 = cfg->ip;
              ins->cil_code = D.30461;
              ins->dreg = 0;
              D.31240 = *sp;
              D.31422 = D.31240->dreg;
              ins->sreg1 = D.31422;
              ins->data.op[0].const_val = 0;
              ins->type = 1;
              D.32517 = &constrained_call->byval_arg;
              type_to_eval_stack_type (cfg, D.32517, ins);
              D.30988 = ins->type;
              D.30989 = (<unnamed type>) D.30988;
              D.32568 = alloc_dreg (cfg, D.30989);
              D.32569 = (int) D.32568;
              ins->dreg = D.32569;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.32570>; else goto <D.32571>;
              <D.32570>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = ins;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              ins->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              goto <D.32572>;
              <D.32571>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.32572>:
              ins->klass = constrained_call;
              D.32573 = mono_class_check_context_used (constrained_call);
              D.32574 = handle_box (cfg, ins, constrained_call, D.32573, &bblock);
              *sp = D.32574;
              D.30793 = cfg->exception_type;
              if (D.30793 != 0) goto exception_exit; else goto <D.32575>;
              <D.32575>:
              <D.32565>:
            }
            <D.32537>:
            virtual = 0;
            <D.32534>:
            <D.32511>:
            constrained_call = 0B;
            <D.32287>:
            if (calli == 0) goto <D.32576>; else goto <D.32577>;
            <D.32576>:
            D.32578 = check_call_signature (cfg, fsig, sp);
            if (D.32578 != 0) goto <D.32579>; else goto <D.32580>;
            <D.32579>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.32581>; else goto <D.32582>;
            <D.32581>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.32583>; else goto <D.32584>;
            <D.32583>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.32584>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.32582>:
            D.32585 = mini_get_debug_options ();
            D.32586 = D.32585->break_on_unverified;
            if (D.32586 != 0) goto <D.32587>; else goto unverified;
            <D.32587>:
            raise (5);
            <D.32580>:
            <D.32577>:
            if (cmethod != 0B) goto <D.32588>; else goto <D.32589>;
            <D.32588>:
            D.32125 = cmethod->klass;
            D.32590 = D.32125->parent;
            D.32591 = mono_defaults.multicastdelegate_class;
            if (D.32590 == D.32591) goto <D.32592>; else goto <D.32593>;
            <D.32592>:
            D.32594 = cmethod->name;
            D.32595 = strcmp (D.32594, "Invoke");
            if (D.32595 == 0) goto <D.32596>; else goto <D.32597>;
            <D.32596>:
            delegate_invoke = 1;
            <D.32597>:
            <D.32593>:
            <D.32589>:
            if (cmethod != 0B) goto <D.32598>; else goto <D.32599>;
            <D.32598>:
            D.30632 = cfg->opt;
            D.32600 = D.30632 & 2048;
            if (D.32600 != 0) goto <D.32601>; else goto <D.32602>;
            <D.32601>:
            ins = mini_emit_inst_for_sharable_method (cfg, cmethod, fsig, sp);
            if (ins != 0B) goto <D.32603>; else goto <D.32604>;
            <D.32603>:
            bblock.106 = cfg->cbb;
            bblock = bblock.106;
            D.32212 = fsig->ret;
            D.32605 = mono_type_is_void (D.32212);
            if (D.32605 == 0) goto <D.32606>; else goto <D.32607>;
            <D.32606>:
            D.32212 = fsig->ret;
            type_to_eval_stack_type (cfg, D.32212, ins);
            emit_widen = 0;
            <D.32607>:
            goto call_end;
            <D.32604>:
            <D.32602>:
            <D.32599>:
            D.30278 = cfg->generic_sharing_context;
            if (D.30278 != 0B) goto <D.32608>; else goto <D.32609>;
            <D.32608>:
            if (cmethod != 0B) goto <D.32610>; else goto <D.32611>;
            <D.32610>:
            D.32125 = cmethod->klass;
            D.30178 = method->klass;
            if (D.32125 != D.30178) goto <D.32612>; else goto <D.32613>;
            <D.32612>:
            D.32125 = cmethod->klass;
            D.32614 = D.32125->generic_class;
            if (D.32614 != 0B) goto <D.32615>; else goto <D.32616>;
            <D.32615>:
            D.32617 = mono_method_is_generic_sharable (cmethod, 1);
            if (D.32617 != 0) goto <D.32618>; else goto <D.32619>;
            <D.32618>:
            D.32125 = cmethod->klass;
            D.32620 = mono_class_needs_cctor_run (D.32125, method);
            if (D.32620 != 0) goto <D.32621>; else goto <D.32622>;
            <D.32621>:
            D.32125 = cmethod->klass;
            emit_generic_class_init (cfg, D.32125);
            D.32125 = cmethod->klass;
            if (D.32125 == 0B) goto <D.32623>; else goto <D.32625>;
            <D.32625>:
            D.32125 = cmethod->klass;
            D.32626 = D.32125->exception_type;
            if (D.32626 != 0) goto <D.32623>; else goto <D.32624>;
            <D.32623>:
            D.32125 = cmethod->klass;
            cfg->exception_ptr = D.32125;
            D.32627 = mini_get_debug_options ();
            D.32628 = D.32627->break_on_unverified;
            if (D.32628 != 0) goto <D.32629>; else goto load_error;
            <D.32629>:
            raise (5);
            <D.32624>:
            <D.32622>:
            <D.32619>:
            <D.32616>:
            <D.32613>:
            <D.32611>:
            <D.32609>:
            if (cmethod != 0B) goto <D.32630>; else goto <D.32631>;
            <D.32630>:
            check_method_sharing (cfg, cmethod, &pass_vtable, &pass_mrgctx);
            <D.32631>:
            D.30278 = cfg->generic_sharing_context;
            if (D.30278 != 0B) goto <D.32632>; else goto <D.32633>;
            <D.32632>:
            if (cmethod != 0B) goto <D.32634>; else goto <D.32635>;
            <D.32634>:
            {
              struct MonoGenericContext * cmethod_context;

              cmethod_context = mono_method_get_context (cmethod);
              context_used = mini_method_check_context_used (cfg, cmethod);
              if (context_used != 0) goto <D.32636>; else goto <D.32637>;
              <D.32636>:
              D.32125 = cmethod->klass;
              D.32304 = D.32125->flags;
              D.32305 = D.32304 & 32;
              if (D.32305 != 0) goto <D.32638>; else goto <D.32639>;
              <D.32638>:
              if (cmethod_context == 0B) goto <D.32640>; else goto <D.32642>;
              <D.32642>:
              D.32643 = cmethod_context->method_inst;
              if (D.32643 == 0B) goto <D.32640>; else goto <D.32641>;
              <D.32640>:
              pass_imt_from_rgctx = 1;
              <D.32641>:
              <D.32639>:
              <D.32637>:
              if (context_used != 0) goto <D.32646>; else goto <D.32647>;
              <D.32646>:
              D.30539 = method->flags;
              D.30540 = (int) D.30539;
              D.30541 = D.30540 & 16;
              if (D.30541 != 0) goto <D.32644>; else goto <D.32648>;
              <D.32648>:
              D.30178 = method->klass;
              D.30331 = BIT_FIELD_REF <*D.30178, 64, 256>;
              D.30332 = D.30331 & 1152921504606846976;
              if (D.30332 != 0) goto <D.32644>; else goto <D.32645>;
              <D.32644>:
              mono_get_vtable_var (cfg);
              <D.32645>:
              <D.32647>:
            }
            <D.32635>:
            <D.32633>:
            pass_vtable.107 = pass_vtable;
            if (pass_vtable.107 != 0) goto <D.32650>; else goto <D.32651>;
            <D.32650>:
            if (context_used != 0) goto <D.32652>; else goto <D.32653>;
            <D.32652>:
            D.32125 = cmethod->klass;
            vtable_arg = emit_get_rgctx_klass (cfg, context_used, D.32125, 2);
            goto <D.32654>;
            <D.32653>:
            {
              struct MonoVTable * vtable;

              D.30267 = cfg->domain;
              D.32125 = cmethod->klass;
              vtable = mono_class_vtable (D.30267, D.32125);
              D.32125 = cmethod->klass;
              if (D.32125 == 0B) goto <D.32655>; else goto <D.32657>;
              <D.32657>:
              D.32125 = cmethod->klass;
              D.32626 = D.32125->exception_type;
              if (D.32626 != 0) goto <D.32655>; else goto <D.32656>;
              <D.32655>:
              D.32125 = cmethod->klass;
              cfg->exception_ptr = D.32125;
              D.32658 = mini_get_debug_options ();
              D.32659 = D.32658->break_on_unverified;
              if (D.32659 != 0) goto <D.32660>; else goto load_error;
              <D.32660>:
              raise (5);
              <D.32656>:
              D.30241 = cfg->mempool;
              vtable_arg = mono_mempool_alloc (D.30241, 80);
              vtable_arg->data.op[1].const_val = 0;
              D.32661 = vtable_arg->data.op[1].const_val;
              vtable_arg->data.op[0].const_val = D.32661;
              vtable_arg->prev = 0B;
              D.32662 = vtable_arg->prev;
              vtable_arg->next = D.32662;
              D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.30635 = D.30634 & 33554432;
              if (D.30635 != 0) goto <D.32664>; else goto <D.32665>;
              <D.32664>:
              iftmp.108 = 732;
              goto <D.32666>;
              <D.32665>:
              iftmp.108 = 363;
              <D.32666>:
              vtable_arg->opcode = iftmp.108;
              vtable_arg->flags = 0;
              vtable_arg->type = 0;
              vtable_arg->dreg = -1;
              vtable_arg->sreg3 = -1;
              D.32667 = vtable_arg->sreg3;
              vtable_arg->sreg2 = D.32667;
              D.32668 = vtable_arg->sreg2;
              vtable_arg->sreg1 = D.32668;
              D.30461 = cfg->ip;
              vtable_arg->cil_code = D.30461;
              D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.30635 = D.30634 & 33554432;
              if (D.30635 != 0) goto <D.32670>; else goto <D.32671>;
              <D.32670>:
              iftmp.109 = vtable->klass;
              goto <D.32672>;
              <D.32671>:
              iftmp.109 = vtable;
              <D.32672>:
              vtable_arg->data.op[0].p = iftmp.109;
              vtable_arg->data.op[1].src = 14B;
              vtable_arg->type = 3;
              D.32673 = alloc_dreg (cfg, 3);
              D.32674 = (int) D.32673;
              vtable_arg->dreg = D.32674;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.32675>; else goto <D.32676>;
              <D.32675>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = vtable_arg;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              vtable_arg->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = vtable_arg;
              goto <D.32677>;
              <D.32676>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = vtable_arg;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.32677>:
            }
            <D.32654>:
            <D.32651>:
            pass_mrgctx.110 = pass_mrgctx;
            if (pass_mrgctx.110 != 0) goto <D.32679>; else goto <D.32680>;
            <D.32679>:
            D.32681 = vtable_arg != 0B;
            D.32682 = (long int) D.32681;
            D.32683 = __builtin_expect (D.32682, 0);
            if (D.32683 != 0) goto <D.32684>; else goto <D.32685>;
            <D.32684>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 7986, "!vtable_arg");
            <D.32685>:
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 == 0) goto <D.32686>; else goto <D.32687>;
            <D.32686>:
            D.32125 = cmethod->klass;
            mono_class_setup_vtable (D.32125);
            D.32125 = cmethod->klass;
            if (D.32125 == 0B) goto <D.32688>; else goto <D.32690>;
            <D.32690>:
            D.32125 = cmethod->klass;
            D.32626 = D.32125->exception_type;
            if (D.32626 != 0) goto <D.32688>; else goto <D.32689>;
            <D.32688>:
            D.32125 = cmethod->klass;
            cfg->exception_ptr = D.32125;
            D.32691 = mini_get_debug_options ();
            D.32692 = D.32691->break_on_unverified;
            if (D.32692 != 0) goto <D.32693>; else goto load_error;
            <D.32693>:
            raise (5);
            <D.32689>:
            <D.32687>:
            vtable_arg = emit_get_rgctx_method (cfg, context_used, cmethod, 8);
            D.32161 = cmethod->flags;
            D.32162 = (int) D.32161;
            D.32696 = D.32162 & 64;
            if (D.32696 == 0) goto <D.32694>; else goto <D.32697>;
            <D.32697>:
            D.32161 = cmethod->flags;
            D.32162 = (int) D.32161;
            D.32698 = D.32162 & 32;
            if (D.32698 != 0) goto <D.32694>; else goto <D.32699>;
            <D.32699>:
            D.32125 = cmethod->klass;
            if (D.32125 != 0B) goto <D.32700>; else goto <D.32695>;
            <D.32700>:
            D.32125 = cmethod->klass;
            D.32304 = D.32125->flags;
            D.32701 = D.32304 & 256;
            if (D.32701 != 0) goto <D.32694>; else goto <D.32695>;
            <D.32694>:
            D.32125 = cmethod->klass;
            D.32126 = BIT_FIELD_REF <*D.32125, 64, 256>;
            D.32168 = D.32126 & 2199023255552;
            if (D.32168 == 0) goto <D.32702>; else goto <D.32703>;
            <D.32702>:
            if (virtual != 0) goto <D.32704>; else goto <D.32705>;
            <D.32704>:
            check_this = 1;
            <D.32705>:
            virtual = 0;
            <D.32703>:
            <D.32695>:
            <D.32680>:
            if (pass_imt_from_rgctx != 0) goto <D.32706>; else goto <D.32707>;
            <D.32706>:
            pass_vtable.107 = pass_vtable;
            D.32708 = pass_vtable.107 != 0;
            D.32709 = (long int) D.32708;
            D.32710 = __builtin_expect (D.32709, 0);
            if (D.32710 != 0) goto <D.32711>; else goto <D.32712>;
            <D.32711>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8010, "!pass_vtable");
            <D.32712>:
            D.32713 = cmethod == 0B;
            D.32714 = (long int) D.32713;
            D.32715 = __builtin_expect (D.32714, 0);
            if (D.32715 != 0) goto <D.32716>; else goto <D.32717>;
            <D.32716>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8011, "cmethod");
            <D.32717>:
            imt_arg = emit_get_rgctx_method (cfg, context_used, cmethod, 5);
            <D.32707>:
            if (check_this != 0) goto <D.32718>; else goto <D.32719>;
            <D.32718>:
            D.30670 = cfg->flags;
            D.30869 = D.30670 | 128;
            cfg->flags = D.30869;
            D.30229 = BIT_FIELD_REF <*cfg, 64, 5632>;
            D.30870 = D.30229 & 144115188075855872;
            if (D.30870 != 0) goto <D.32720>; else goto <D.32721>;
            <D.32720>:
            D.30229 = BIT_FIELD_REF <*cfg, 64, 5632>;
            D.30870 = D.30229 & 144115188075855872;
            if (D.30870 != 0) goto <D.32722>; else goto <D.32723>;
            <D.32722>:
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.32724 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.32724;
              inst->prev = 0B;
              D.32725 = inst->prev;
              inst->next = D.32725;
              inst->opcode = 323;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.32726 = inst->sreg3;
              inst->sreg2 = D.32726;
              D.32727 = inst->sreg2;
              inst->sreg1 = D.32727;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = -1;
              D.31240 = *sp;
              D.31422 = D.31240->dreg;
              inst->sreg1 = D.31422;
              inst->data.op[1].const_val = 0;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.32728>; else goto <D.32729>;
              <D.32728>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.32730>;
              <D.32729>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.32730>:
            }
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.32731 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.32731;
              inst->prev = 0B;
              D.32732 = inst->prev;
              inst->next = D.32732;
              inst->opcode = 451;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.32733 = inst->sreg3;
              inst->sreg2 = D.32733;
              D.32734 = inst->sreg2;
              inst->sreg1 = D.32734;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->data.op[1].p = "NullReferenceException";
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.32735>; else goto <D.32736>;
              <D.32735>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.32737>;
              <D.32736>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.32737>:
            }
            goto <D.32738>;
            <D.32723>:
            <D.32738>:
            goto <D.32739>;
            <D.32721>:
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.32740 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.32740;
              inst->prev = 0B;
              D.32741 = inst->prev;
              inst->next = D.32741;
              inst->opcode = 340;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.32742 = inst->sreg3;
              inst->sreg2 = D.32742;
              D.32743 = inst->sreg2;
              inst->sreg1 = D.32743;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = -1;
              D.31240 = *sp;
              D.31422 = D.31240->dreg;
              inst->sreg1 = D.31422;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.32744>; else goto <D.32745>;
              <D.32744>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.32746>;
              <D.32745>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.32746>:
            }
            <D.32739>:
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.32747 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.32747;
              inst->prev = 0B;
              D.32748 = inst->prev;
              inst->next = D.32748;
              inst->opcode = 799;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.32749 = inst->sreg3;
              inst->sreg2 = D.32749;
              D.32750 = inst->sreg2;
              inst->sreg1 = D.32750;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = -1;
              D.31240 = *sp;
              D.31422 = D.31240->dreg;
              inst->sreg1 = D.31422;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.32751>; else goto <D.32752>;
              <D.32751>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.32753>;
              <D.32752>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.32753>:
            }
            <D.32719>:
            if (cmethod != 0B) goto <D.32759>; else goto <D.32760>;
            <D.32759>:
            if (virtual != 0) goto <D.32761>; else goto <D.32762>;
            <D.32761>:
            D.32161 = cmethod->flags;
            D.32162 = (int) D.32161;
            D.32696 = D.32162 & 64;
            if (D.32696 != 0) goto <D.32763>; else goto <D.32764>;
            <D.32763>:
            D.32161 = cmethod->flags;
            D.32162 = (int) D.32161;
            D.32698 = D.32162 & 32;
            if (D.32698 == 0) goto <D.32765>; else goto <D.32756>;
            <D.32765>:
            D.32125 = cmethod->klass;
            if (D.32125 == 0B) goto <D.32757>; else goto <D.32766>;
            <D.32766>:
            D.32125 = cmethod->klass;
            D.32304 = D.32125->flags;
            D.32701 = D.32304 & 256;
            if (D.32701 == 0) goto <D.32757>; else goto <D.32756>;
            <D.32756>:
            D.32245 = BIT_FIELD_REF <*cmethod, 64, 256>;
            D.32767 = D.32245 & 4467570830351532032;
            if (D.32767 == 1297036692682702848) goto <D.32757>; else goto <D.32758>;
            <D.32757>:
            D.32768 = fsig->generic_param_count;
            if (D.32768 != 0) goto <D.32769>; else goto <D.32770>;
            <D.32769>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 == 0) goto <D.32754>; else goto <D.32771>;
            <D.32771>:
            D.32772 = mini_is_gsharedvt_signature (cfg, fsig);
            if (D.32772 == 0) goto <D.32754>; else goto <D.32755>;
            <D.32754>:
            {
              struct MonoInst * this_temp;
              struct MonoInst * this_arg_temp;
              struct MonoInst * store;
              struct MonoInst * iargs[4];
              gboolean use_imt;

              try
                {
                  use_imt = 0;
                  D.32069 = BIT_FIELD_REF <*fsig, 64, 64>;
                  D.32773 = D.32069 & 64;
                  D.32774 = D.32773 == 0;
                  D.32775 = (long int) D.32774;
                  D.32776 = __builtin_expect (D.32775, 0);
                  if (D.32776 != 0) goto <D.32777>; else goto <D.32778>;
                  <D.32777>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8031, "fsig->is_inflated");
                  <D.32778>:
                  D.30211 = cfg->method;
                  if (D.30211 != method) goto <D.32779>; else goto <D.32780>;
                  <D.32779>:
                  D.30183 = BIT_FIELD_REF <*method, 64, 256>;
                  D.30184 = D.30183 & 4467570830351532032;
                  if (D.30184 == 0) goto <D.32781>; else goto <D.32782>;
                  <D.32781>:
                  D.30322 = cfg->verbose_level;
                  if (D.30322 > 1) goto <D.32783>; else goto <D.32784>;
                  <D.32783>:
                  printf ("inline failed: %s\n", "virtual generic call");
                  <D.32784>:
                  goto inline_failure;
                  <D.32782>:
                  <D.32780>:
                  D.30389 = cfg->gsharedvt;
                  if (D.30389 != 0) goto <D.32785>; else goto <D.32786>;
                  <D.32785>:
                  D.32787 = mini_is_gsharedvt_signature (cfg, fsig);
                  if (D.32787 != 0) goto <D.32788>; else goto <D.32789>;
                  <D.32788>:
                  D.30389 = cfg->gsharedvt;
                  if (D.30389 != 0) goto <D.32790>; else goto <D.32791>;
                  <D.32790>:
                  D.30178 = method->klass;
                  D.31934 = D.30178->name_space;
                  D.30178 = method->klass;
                  D.31935 = D.30178->name;
                  D.31936 = method->name;
                  D.31937 = method->signature;
                  D.31938 = D.31937->param_count;
                  D.31939 = (int) D.31938;
                  D.31121 = *ip;
                  D.31122 = (int) D.31121;
                  D.32792 = mono_opcode_name (D.31122);
                  D.32793 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.31934, D.31935, D.31936, D.31939, D.32792, "method-to-ir.c", 8037);
                  cfg->exception_message = D.32793;
                  D.30322 = cfg->verbose_level;
                  if (D.30322 > 1) goto <D.32794>; else goto <D.32795>;
                  <D.32794>:
                  D.31944 = cfg->exception_message;
                  printf ("%s\n", D.31944);
                  <D.32795>:
                  mono_cfg_set_exception (cfg, 11);
                  goto exception_exit;
                  <D.32791>:
                  <D.32789>:
                  <D.32786>:
                  if (use_imt != 0) goto <D.32796>; else goto <D.32797>;
                  <D.32796>:
                  D.32798 = imt_arg != 0B;
                  D.32799 = (long int) D.32798;
                  D.32800 = __builtin_expect (D.32799, 0);
                  if (D.32800 != 0) goto <D.32801>; else goto <D.32802>;
                  <D.32801>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8045, "!imt_arg");
                  <D.32802>:
                  if (context_used == 0) goto <D.32803>; else goto <D.32804>;
                  <D.32803>:
                  D.32245 = BIT_FIELD_REF <*cmethod, 64, 256>;
                  D.32805 = D.32245 & 2251799813685248;
                  D.32806 = D.32805 == 0;
                  D.32807 = (long int) D.32806;
                  D.32808 = __builtin_expect (D.32807, 0);
                  if (D.32808 != 0) goto <D.32809>; else goto <D.32810>;
                  <D.32809>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8047, "cmethod->is_inflated");
                  <D.32810>:
                  <D.32804>:
                  imt_arg = emit_get_rgctx_method (cfg, context_used, cmethod, 5);
                  D.31240 = *sp;
                  ins = mono_emit_method_call_full (cfg, cmethod, fsig, 0, sp, D.31240, imt_arg, 0B);
                  goto <D.32811>;
                  <D.32797>:
                  D.31240 = *sp;
                  D.32812 = type_from_stack_type (D.31240);
                  this_temp = mono_compile_create_var (cfg, D.32812, 329);
                  D.30241 = cfg->mempool;
                  store = mono_mempool_alloc (D.30241, 80);
                  store->data.op[1].const_val = 0;
                  D.32813 = store->data.op[1].const_val;
                  store->data.op[0].const_val = D.32813;
                  store->prev = 0B;
                  D.32814 = store->prev;
                  store->next = D.32814;
                  store->opcode = 424;
                  store->flags = 0;
                  store->type = 0;
                  store->dreg = -1;
                  store->sreg3 = -1;
                  D.32815 = store->sreg3;
                  store->sreg2 = D.32815;
                  D.32816 = store->sreg2;
                  store->sreg1 = D.32816;
                  D.30461 = cfg->ip;
                  store->cil_code = D.30461;
                  D.30978 = cfg->varinfo;
                  D.32817 = this_temp->data.op[0].const_val;
                  D.32818 = (long unsigned int) D.32817;
                  D.32819 = D.32818 * 8;
                  D.32820 = D.30978 + D.32819;
                  D.32821 = *D.32820;
                  D.32822 = D.32821->data.op[1].vtype;
                  D.32823 = mono_type_to_regmove (cfg, D.32822);
                  D.32824 = (short unsigned int) D.32823;
                  store->opcode = D.32824;
                  D.30978 = cfg->varinfo;
                  D.32817 = this_temp->data.op[0].const_val;
                  D.32818 = (long unsigned int) D.32817;
                  D.32819 = D.32818 * 8;
                  D.32820 = D.30978 + D.32819;
                  D.32821 = *D.32820;
                  D.32825 = D.32821->klass;
                  store->klass = D.32825;
                  D.31240 = *sp;
                  D.31422 = D.31240->dreg;
                  store->sreg1 = D.31422;
                  D.30978 = cfg->varinfo;
                  D.32817 = this_temp->data.op[0].const_val;
                  D.32818 = (long unsigned int) D.32817;
                  D.32819 = D.32818 * 8;
                  D.32820 = D.30978 + D.32819;
                  D.32821 = *D.32820;
                  D.32826 = D.32821->dreg;
                  store->dreg = D.32826;
                  D.32827 = store->opcode;
                  if (D.32827 == 427) goto <D.32828>; else goto <D.32829>;
                  <D.32828>:
                  D.30978 = cfg->varinfo;
                  D.32817 = this_temp->data.op[0].const_val;
                  D.32818 = (long unsigned int) D.32817;
                  D.32819 = D.32818 * 8;
                  D.32820 = D.30978 + D.32819;
                  D.32821 = *D.32820;
                  D.32822 = D.32821->data.op[1].vtype;
                  D.32830 = mono_class_from_mono_type (D.32822);
                  store->klass = D.32830;
                  <D.32829>:
                  bblock.64 = bblock;
                  D.30577 = bblock.64->last_ins;
                  if (D.30577 != 0B) goto <D.32831>; else goto <D.32832>;
                  <D.32831>:
                  bblock.64 = bblock;
                  D.30577 = bblock.64->last_ins;
                  D.30577->next = store;
                  bblock.64 = bblock;
                  D.30577 = bblock.64->last_ins;
                  store->prev = D.30577;
                  bblock.64 = bblock;
                  bblock.64->last_ins = store;
                  goto <D.32833>;
                  <D.32832>:
                  bblock.64 = bblock;
                  bblock.64 = bblock;
                  bblock.64->last_ins = store;
                  D.30577 = bblock.64->last_ins;
                  bblock.64->code = D.30577;
                  <D.32833>:
                  D.30646 = mono_defaults.int_class;
                  D.30647 = &D.30646->byval_arg;
                  this_arg_temp = mono_compile_create_var (cfg, D.30647, 329);
                  D.30241 = cfg->mempool;
                  D.32834 = mono_mempool_alloc (D.30241, 80);
                  iargs[0] = D.32834;
                  D.32835 = iargs[0];
                  D.32835 = iargs[0];
                  D.32835->data.op[1].const_val = 0;
                  D.32836 = D.32835->data.op[1].const_val;
                  D.32835->data.op[0].const_val = D.32836;
                  D.32835 = iargs[0];
                  D.32835 = iargs[0];
                  D.32835->prev = 0B;
                  D.32837 = D.32835->prev;
                  D.32835->next = D.32837;
                  D.32835 = iargs[0];
                  D.32835->opcode = 424;
                  D.32835 = iargs[0];
                  D.32835->flags = 0;
                  D.32835 = iargs[0];
                  D.32835->type = 0;
                  D.32835 = iargs[0];
                  D.32835->dreg = -1;
                  D.32835 = iargs[0];
                  D.32835 = iargs[0];
                  D.32835 = iargs[0];
                  D.32835->sreg3 = -1;
                  D.32838 = D.32835->sreg3;
                  D.32835->sreg2 = D.32838;
                  D.32839 = D.32835->sreg2;
                  D.32835->sreg1 = D.32839;
                  D.32835 = iargs[0];
                  D.30461 = cfg->ip;
                  D.32835->cil_code = D.30461;
                  D.32835 = iargs[0];
                  D.30978 = cfg->varinfo;
                  D.32817 = this_temp->data.op[0].const_val;
                  D.32818 = (long unsigned int) D.32817;
                  D.32819 = D.32818 * 8;
                  D.32820 = D.30978 + D.32819;
                  D.32821 = *D.32820;
                  D.32822 = D.32821->data.op[1].vtype;
                  D.32840 = mono_type_to_regmove (cfg, D.32822);
                  D.32841 = (short unsigned int) D.32840;
                  D.32835->opcode = D.32841;
                  D.30978 = cfg->varinfo;
                  D.32817 = this_temp->data.op[0].const_val;
                  D.32818 = (long unsigned int) D.32817;
                  D.32819 = D.32818 * 8;
                  D.32820 = D.30978 + D.32819;
                  D.32821 = *D.32820;
                  D.32822 = D.32821->data.op[1].vtype;
                  D.32835 = iargs[0];
                  type_to_eval_stack_type (cfg, D.32822, D.32835);
                  D.32835 = iargs[0];
                  D.30978 = cfg->varinfo;
                  D.32817 = this_temp->data.op[0].const_val;
                  D.32818 = (long unsigned int) D.32817;
                  D.32819 = D.32818 * 8;
                  D.32820 = D.30978 + D.32819;
                  D.32821 = *D.32820;
                  D.32825 = D.32821->klass;
                  D.32835->klass = D.32825;
                  D.32835 = iargs[0];
                  D.30978 = cfg->varinfo;
                  D.32817 = this_temp->data.op[0].const_val;
                  D.32818 = (long unsigned int) D.32817;
                  D.32819 = D.32818 * 8;
                  D.32820 = D.30978 + D.32819;
                  D.32821 = *D.32820;
                  D.32826 = D.32821->dreg;
                  D.32835->sreg1 = D.32826;
                  D.32835 = iargs[0];
                  D.32835 = iargs[0];
                  D.32842 = D.32835->type;
                  D.32843 = (<unnamed type>) D.32842;
                  D.32844 = alloc_dreg (cfg, D.32843);
                  D.32845 = (int) D.32844;
                  D.32835->dreg = D.32845;
                  D.32835 = iargs[0];
                  D.32846 = D.32835->opcode;
                  if (D.32846 == 427) goto <D.32847>; else goto <D.32848>;
                  <D.32847>:
                  D.32835 = iargs[0];
                  D.30978 = cfg->varinfo;
                  D.32817 = this_temp->data.op[0].const_val;
                  D.32818 = (long unsigned int) D.32817;
                  D.32819 = D.32818 * 8;
                  D.32820 = D.30978 + D.32819;
                  D.32821 = *D.32820;
                  D.32822 = D.32821->data.op[1].vtype;
                  D.32849 = mono_class_from_mono_type (D.32822);
                  D.32835->klass = D.32849;
                  <D.32848>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.32850>; else goto <D.32851>;
                  <D.32850>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.32835 = iargs[0];
                  D.30490->next = D.32835;
                  D.32835 = iargs[0];
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.32835->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  D.32835 = iargs[0];
                  bblock.106->last_ins = D.32835;
                  goto <D.32852>;
                  <D.32851>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  D.32835 = iargs[0];
                  bblock.106->last_ins = D.32835;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.32852>:
                  D.32853 = emit_get_rgctx_method (cfg, context_used, cmethod, 5);
                  iargs[1] = D.32853;
                  D.30241 = cfg->mempool;
                  D.32854 = mono_mempool_alloc (D.30241, 80);
                  iargs[2] = D.32854;
                  D.32855 = iargs[2];
                  D.32855 = iargs[2];
                  D.32855->data.op[1].const_val = 0;
                  D.32856 = D.32855->data.op[1].const_val;
                  D.32855->data.op[0].const_val = D.32856;
                  D.32855 = iargs[2];
                  D.32855 = iargs[2];
                  D.32855->prev = 0B;
                  D.32857 = D.32855->prev;
                  D.32855->next = D.32857;
                  D.32855 = iargs[2];
                  D.32855->opcode = 314;
                  D.32855 = iargs[2];
                  D.32855->flags = 0;
                  D.32855 = iargs[2];
                  D.32855->type = 0;
                  D.32855 = iargs[2];
                  D.32855->dreg = -1;
                  D.32855 = iargs[2];
                  D.32855 = iargs[2];
                  D.32855 = iargs[2];
                  D.32855->sreg3 = -1;
                  D.32858 = D.32855->sreg3;
                  D.32855->sreg2 = D.32858;
                  D.32859 = D.32855->sreg2;
                  D.32855->sreg1 = D.32859;
                  D.32855 = iargs[2];
                  D.30461 = cfg->ip;
                  D.32855->cil_code = D.30461;
                  D.32855 = iargs[2];
                  D.30978 = cfg->varinfo;
                  D.32860 = this_arg_temp->data.op[0].const_val;
                  D.32861 = (long unsigned int) D.32860;
                  D.32862 = D.32861 * 8;
                  D.32863 = D.30978 + D.32862;
                  D.32864 = *D.32863;
                  D.32855->data.op[0].p = D.32864;
                  D.30978 = cfg->varinfo;
                  D.32860 = this_arg_temp->data.op[0].const_val;
                  D.32861 = (long unsigned int) D.32860;
                  D.32862 = D.32861 * 8;
                  D.32863 = D.30978 + D.32862;
                  D.32864 = *D.32863;
                  D.30978 = cfg->varinfo;
                  D.32860 = this_arg_temp->data.op[0].const_val;
                  D.32861 = (long unsigned int) D.32860;
                  D.32862 = D.32861 * 8;
                  D.32863 = D.30978 + D.32862;
                  D.32864 = *D.32863;
                  D.32865 = D.32864->flags;
                  D.32866 = D.32865 | 16;
                  D.32864->flags = D.32866;
                  D.32855 = iargs[2];
                  D.32855->type = 5;
                  D.32855 = iargs[2];
                  D.30978 = cfg->varinfo;
                  D.32860 = this_arg_temp->data.op[0].const_val;
                  D.32861 = (long unsigned int) D.32860;
                  D.32862 = D.32861 * 8;
                  D.32863 = D.30978 + D.32862;
                  D.32864 = *D.32863;
                  D.32867 = D.32864->klass;
                  D.32855->klass = D.32867;
                  D.32855 = iargs[2];
                  D.32868 = alloc_dreg (cfg, 5);
                  D.32869 = (int) D.32868;
                  D.32855->dreg = D.32869;
                  cfg->has_indirection = 1;
                  D.30389 = cfg->gsharedvt;
                  D.31326 = D.30389 != 0;
                  D.31327 = (long int) D.31326;
                  D.31328 = __builtin_expect (D.31327, 0);
                  if (D.31328 != 0) goto <D.32870>; else goto <D.32871>;
                  <D.32870>:
                  D.30978 = cfg->varinfo;
                  D.32860 = this_arg_temp->data.op[0].const_val;
                  D.32861 = (long unsigned int) D.32860;
                  D.32862 = D.32861 * 8;
                  D.32863 = D.30978 + D.32862;
                  D.32864 = *D.32863;
                  D.32872 = D.32864->data.op[1].vtype;
                  D.32873 = mini_is_gsharedvt_variable_type (cfg, D.32872);
                  if (D.32873 != 0) goto <D.32874>; else goto <D.32875>;
                  <D.32874>:
                  handle_gsharedvt_ldaddr (cfg);
                  <D.32875>:
                  <D.32871>:
                  if (0 != 0) goto <D.32876>; else goto <D.32877>;
                  <D.32876>:
                  {
                    struct MonoInst * var1;
                    struct MonoInst * var2;

                    D.30978 = cfg->varinfo;
                    D.32860 = this_arg_temp->data.op[0].const_val;
                    D.32861 = (long unsigned int) D.32860;
                    D.32862 = D.32861 * 8;
                    D.32863 = D.30978 + D.32862;
                    D.32864 = *D.32863;
                    D.32879 = D.32864->dreg;
                    D.32880 = D.32879 + 1;
                    D.32881 = (unsigned int) D.32880;
                    D.31341 = cfg->vreg_to_inst_len;
                    if (D.32881 < D.31341) goto <D.32882>; else goto <D.32883>;
                    <D.32882>:
                    D.31344 = cfg->vreg_to_inst;
                    D.30978 = cfg->varinfo;
                    D.32860 = this_arg_temp->data.op[0].const_val;
                    D.32861 = (long unsigned int) D.32860;
                    D.32862 = D.32861 * 8;
                    D.32863 = D.30978 + D.32862;
                    D.32864 = *D.32863;
                    D.32879 = D.32864->dreg;
                    D.32884 = (sizetype) D.32879;
                    D.32885 = D.32884 + 1;
                    D.32886 = D.32885 * 8;
                    D.32887 = D.31344 + D.32886;
                    iftmp.111 = *D.32887;
                    goto <D.32888>;
                    <D.32883>:
                    iftmp.111 = 0B;
                    <D.32888>:
                    var1 = iftmp.111;
                    D.30978 = cfg->varinfo;
                    D.32860 = this_arg_temp->data.op[0].const_val;
                    D.32861 = (long unsigned int) D.32860;
                    D.32862 = D.32861 * 8;
                    D.32863 = D.30978 + D.32862;
                    D.32864 = *D.32863;
                    D.32879 = D.32864->dreg;
                    D.32890 = D.32879 + 2;
                    D.32891 = (unsigned int) D.32890;
                    D.31341 = cfg->vreg_to_inst_len;
                    if (D.32891 < D.31341) goto <D.32892>; else goto <D.32893>;
                    <D.32892>:
                    D.31344 = cfg->vreg_to_inst;
                    D.30978 = cfg->varinfo;
                    D.32860 = this_arg_temp->data.op[0].const_val;
                    D.32861 = (long unsigned int) D.32860;
                    D.32862 = D.32861 * 8;
                    D.32863 = D.30978 + D.32862;
                    D.32864 = *D.32863;
                    D.32879 = D.32864->dreg;
                    D.32884 = (sizetype) D.32879;
                    D.32894 = D.32884 + 2;
                    D.32895 = D.32894 * 8;
                    D.32896 = D.31344 + D.32895;
                    iftmp.112 = *D.32896;
                    goto <D.32897>;
                    <D.32893>:
                    iftmp.112 = 0B;
                    <D.32897>:
                    var2 = iftmp.112;
                    D.32898 = var1 == 0B;
                    D.32899 = (long int) D.32898;
                    D.32900 = __builtin_expect (D.32899, 0);
                    if (D.32900 != 0) goto <D.32901>; else goto <D.32902>;
                    <D.32901>:
                    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8062, "var1");
                    <D.32902>:
                    D.32903 = var2 == 0B;
                    D.32904 = (long int) D.32903;
                    D.32905 = __builtin_expect (D.32904, 0);
                    if (D.32905 != 0) goto <D.32906>; else goto <D.32907>;
                    <D.32906>:
                    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8062, "var2");
                    <D.32907>:
                    D.32908 = var1->flags;
                    D.32909 = D.32908 | 16;
                    var1->flags = D.32909;
                    D.32910 = var2->flags;
                    D.32911 = D.32910 | 16;
                    var2->flags = D.32911;
                  }
                  <D.32877>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.32912>; else goto <D.32913>;
                  <D.32912>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.32855 = iargs[2];
                  D.30490->next = D.32855;
                  D.32855 = iargs[2];
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.32855->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  D.32855 = iargs[2];
                  bblock.106->last_ins = D.32855;
                  goto <D.32914>;
                  <D.32913>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  D.32855 = iargs[2];
                  bblock.106->last_ins = D.32855;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.32914>:
                  addr = mono_emit_jit_icall (cfg, mono_helper_compile_generic_method, &iargs);
                  D.30241 = cfg->mempool;
                  D.32915 = mono_mempool_alloc (D.30241, 80);
                  *sp = D.32915;
                  D.31240 = *sp;
                  D.31240 = *sp;
                  D.31240->data.op[1].const_val = 0;
                  D.32916 = D.31240->data.op[1].const_val;
                  D.31240->data.op[0].const_val = D.32916;
                  D.31240 = *sp;
                  D.31240 = *sp;
                  D.31240->prev = 0B;
                  D.32917 = D.31240->prev;
                  D.31240->next = D.32917;
                  D.31240 = *sp;
                  D.31240->opcode = 424;
                  D.31240 = *sp;
                  D.31240->flags = 0;
                  D.31240 = *sp;
                  D.31240->type = 0;
                  D.31240 = *sp;
                  D.31240->dreg = -1;
                  D.31240 = *sp;
                  D.31240 = *sp;
                  D.31240 = *sp;
                  D.31240->sreg3 = -1;
                  D.32918 = D.31240->sreg3;
                  D.31240->sreg2 = D.32918;
                  D.32919 = D.31240->sreg2;
                  D.31240->sreg1 = D.32919;
                  D.31240 = *sp;
                  D.30461 = cfg->ip;
                  D.31240->cil_code = D.30461;
                  D.31240 = *sp;
                  D.30978 = cfg->varinfo;
                  D.32860 = this_arg_temp->data.op[0].const_val;
                  D.32861 = (long unsigned int) D.32860;
                  D.32862 = D.32861 * 8;
                  D.32863 = D.30978 + D.32862;
                  D.32864 = *D.32863;
                  D.32872 = D.32864->data.op[1].vtype;
                  D.32920 = mono_type_to_regmove (cfg, D.32872);
                  D.32921 = (short unsigned int) D.32920;
                  D.31240->opcode = D.32921;
                  D.30978 = cfg->varinfo;
                  D.32860 = this_arg_temp->data.op[0].const_val;
                  D.32861 = (long unsigned int) D.32860;
                  D.32862 = D.32861 * 8;
                  D.32863 = D.30978 + D.32862;
                  D.32864 = *D.32863;
                  D.32872 = D.32864->data.op[1].vtype;
                  D.31240 = *sp;
                  type_to_eval_stack_type (cfg, D.32872, D.31240);
                  D.31240 = *sp;
                  D.30978 = cfg->varinfo;
                  D.32860 = this_arg_temp->data.op[0].const_val;
                  D.32861 = (long unsigned int) D.32860;
                  D.32862 = D.32861 * 8;
                  D.32863 = D.30978 + D.32862;
                  D.32864 = *D.32863;
                  D.32867 = D.32864->klass;
                  D.31240->klass = D.32867;
                  D.31240 = *sp;
                  D.30978 = cfg->varinfo;
                  D.32860 = this_arg_temp->data.op[0].const_val;
                  D.32861 = (long unsigned int) D.32860;
                  D.32862 = D.32861 * 8;
                  D.32863 = D.30978 + D.32862;
                  D.32864 = *D.32863;
                  D.32879 = D.32864->dreg;
                  D.31240->sreg1 = D.32879;
                  D.31240 = *sp;
                  D.31240 = *sp;
                  D.32922 = D.31240->type;
                  D.32923 = (<unnamed type>) D.32922;
                  D.32924 = alloc_dreg (cfg, D.32923);
                  D.32925 = (int) D.32924;
                  D.31240->dreg = D.32925;
                  D.31240 = *sp;
                  D.32926 = D.31240->opcode;
                  if (D.32926 == 427) goto <D.32927>; else goto <D.32928>;
                  <D.32927>:
                  D.31240 = *sp;
                  D.30978 = cfg->varinfo;
                  D.32860 = this_arg_temp->data.op[0].const_val;
                  D.32861 = (long unsigned int) D.32860;
                  D.32862 = D.32861 * 8;
                  D.32863 = D.30978 + D.32862;
                  D.32864 = *D.32863;
                  D.32872 = D.32864->data.op[1].vtype;
                  D.32929 = mono_class_from_mono_type (D.32872);
                  D.31240->klass = D.32929;
                  <D.32928>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.32930>; else goto <D.32931>;
                  <D.32930>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.31240 = *sp;
                  D.30490->next = D.31240;
                  D.31240 = *sp;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.31240->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  D.31240 = *sp;
                  bblock.106->last_ins = D.31240;
                  goto <D.32932>;
                  <D.32931>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  D.31240 = *sp;
                  bblock.106->last_ins = D.31240;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.32932>:
                  ins = mono_emit_calli (cfg, fsig, sp, addr, 0B, 0B);
                  <D.32811>:
                  goto call_end;
                }
              finally
                {
                  iargs = {CLOBBER};
                }
            }
            <D.32755>:
            <D.32770>:
            <D.32758>:
            <D.32764>:
            <D.32762>:
            <D.32760>:
            if (cmethod != 0B) goto <D.32933>; else goto <D.32934>;
            <D.32933>:
            D.32125 = cmethod->klass;
            D.32935 = mono_defaults.monitor_class;
            if (D.32125 == D.32935) goto <D.32936>; else goto <D.32937>;
            <D.32936>:
            D.32594 = cmethod->name;
            D.32938 = strcmp (D.32594, "Enter");
            if (D.32938 == 0) goto <D.32939>; else goto <D.32940>;
            <D.32939>:
            D.32941 = mono_method_signature (cmethod);
            D.32942 = D.32941->param_count;
            if (D.32942 == 1) goto <D.32943>; else goto <D.32944>;
            <D.32943>:
            {
              struct MonoBasicBlock * tbb;

              D.30372 = cfg->cil_offset_to_bb;
              D.31664 = ip + 5;
              D.32223 = (long int) D.31664;
              D.30377 = cfg->cil_start;
              D.30378 = (long int) D.30377;
              D.32945 = D.32223 - D.30378;
              D.32946 = (long unsigned int) D.32945;
              D.32947 = D.32946 * 8;
              D.32948 = D.30372 + D.32947;
              tbb = *D.32948;
              if (tbb == 0B) goto <D.32949>; else goto <D.32950>;
              <D.32949>:
              D.31664 = ip + 5;
              if (D.31664 >= end) goto <D.32951>; else goto <D.32953>;
              <D.32953>:
              D.31664 = ip + 5;
              D.30388 = header->code;
              if (D.31664 < D.30388) goto <D.32951>; else goto <D.32952>;
              <D.32951>:
              D.30389 = cfg->gsharedvt;
              if (D.30389 != 0) goto <D.32954>; else goto <D.32955>;
              <D.32954>:
              D.30322 = cfg->verbose_level;
              if (D.30322 > 2) goto <D.32956>; else goto <D.32957>;
              <D.32956>:
              printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
              <D.32957>:
              mono_cfg_set_exception (cfg, 11);
              goto exception_exit;
              <D.32955>:
              D.32958 = mini_get_debug_options ();
              D.32959 = D.32958->break_on_unverified;
              if (D.32959 != 0) goto <D.32960>; else goto unverified;
              <D.32960>:
              raise (5);
              <D.32952>:
              D.30241 = cfg->mempool;
              tbb = mono_mempool_alloc0 (D.30241, 296);
              D.30349 = cfg->num_bblocks;
              D.32961 = D.30349;
              D.32962 = D.32961 + 1;
              cfg->num_bblocks = D.32962;
              D.32963 = (int) D.32961;
              tbb->block_num = D.32963;
              D.31664 = ip + 5;
              tbb->cil_code = D.31664;
              D.32964 = tbb->cil_code;
              if (D.32964 != 0B) goto <D.32965>; else goto <D.32966>;
              <D.32965>:
              D.30372 = cfg->cil_offset_to_bb;
              D.32964 = tbb->cil_code;
              D.32967 = (long int) D.32964;
              D.30377 = cfg->cil_start;
              D.30378 = (long int) D.30377;
              D.32968 = D.32967 - D.30378;
              D.32969 = (long unsigned int) D.32968;
              D.32970 = D.32969 * 8;
              D.32971 = D.30372 + D.32970;
              *D.32971 = tbb;
              <D.32966>:
              D.30408 = cfg->real_offset;
              tbb->real_offset = D.30408;
              <D.32950>:
              D.32972 = BIT_FIELD_REF <*tbb, 64, 1472>;
              D.32973 = D.32972 & 2199023255552;
              if (D.32973 != 0) goto <D.32974>; else goto <D.32975>;
              <D.32974>:
              D.32976 = tbb->region;
              D.32977 = D.32976 & 7;
              if (D.32977 == 2) goto <D.32978>; else goto <D.32979>;
              <D.32978>:
              tbb->extend_try_block = 1;
              <D.32979>:
              <D.32975>:
            }
            <D.32944>:
            <D.32940>:
            <D.32937>:
            <D.32934>:
            if (cmethod != 0B) goto <D.32980>; else goto <D.32981>;
            <D.32980>:
            D.30632 = cfg->opt;
            D.32600 = D.30632 & 2048;
            if (D.32600 != 0) goto <D.32982>; else goto <D.32983>;
            <D.32982>:
            ins = mini_emit_inst_for_method (cfg, cmethod, fsig, sp);
            if (ins != 0B) goto <D.32984>; else goto <D.32985>;
            <D.32984>:
            bblock.106 = cfg->cbb;
            bblock = bblock.106;
            D.32212 = fsig->ret;
            D.32986 = mono_type_is_void (D.32212);
            if (D.32986 == 0) goto <D.32987>; else goto <D.32988>;
            <D.32987>:
            D.32212 = fsig->ret;
            type_to_eval_stack_type (cfg, D.32212, ins);
            emit_widen = 0;
            <D.32988>:
            goto call_end;
            <D.32985>:
            <D.32983>:
            <D.32981>:
            if (cmethod != 0B) goto <D.32991>; else goto <D.32992>;
            <D.32991>:
            D.30632 = cfg->opt;
            D.32993 = D.30632 & 4;
            if (D.32993 != 0) goto <D.32994>; else goto <D.32995>;
            <D.32994>:
            if (virtual == 0) goto <D.32989>; else goto <D.32996>;
            <D.32996>:
            D.32161 = cmethod->flags;
            D.32162 = (int) D.32161;
            D.32696 = D.32162 & 64;
            if (D.32696 == 0) goto <D.32989>; else goto <D.32997>;
            <D.32997>:
            D.32161 = cmethod->flags;
            D.32162 = (int) D.32161;
            D.32698 = D.32162 & 32;
            if (D.32698 != 0) goto <D.32989>; else goto <D.32998>;
            <D.32998>:
            D.32125 = cmethod->klass;
            if (D.32125 != 0B) goto <D.32999>; else goto <D.32990>;
            <D.32999>:
            D.32125 = cmethod->klass;
            D.32304 = D.32125->flags;
            D.32701 = D.32304 & 256;
            if (D.32701 != 0) goto <D.32989>; else goto <D.32990>;
            <D.32989>:
            if (disable_inline == 0) goto <D.33000>; else goto <D.33001>;
            <D.33000>:
            D.33002 = mono_method_check_inlining (cfg, cmethod);
            if (D.33002 != 0) goto <D.33003>; else goto <D.33004>;
            <D.33003>:
            D.33005 = monoeg_g_list_find (dont_inline, cmethod);
            if (D.33005 == 0B) goto <D.33006>; else goto <D.33007>;
            <D.33006>:
            {
              int costs;
              gboolean always;

              always = 0;
              D.32191 = cmethod->iflags;
              D.32192 = (int) D.32191;
              D.32193 = D.32192 & 4096;
              if (D.32193 != 0) goto <D.33008>; else goto <D.33010>;
              <D.33010>:
              D.32161 = cmethod->flags;
              D.32162 = (int) D.32161;
              D.33011 = D.32162 & 8192;
              if (D.33011 != 0) goto <D.33008>; else goto <D.33009>;
              <D.33008>:
              D.30211 = cfg->method;
              if (D.30211 != method) goto <D.33012>; else goto <D.33013>;
              <D.33012>:
              D.30183 = BIT_FIELD_REF <*method, 64, 256>;
              D.30184 = D.30183 & 4467570830351532032;
              if (D.30184 == 0) goto <D.33014>; else goto <D.33015>;
              <D.33014>:
              D.30322 = cfg->verbose_level;
              if (D.30322 > 1) goto <D.33016>; else goto <D.33017>;
              <D.33016>:
              printf ("inline failed: %s\n", "wrapper call");
              <D.33017>:
              goto inline_failure;
              <D.33015>:
              <D.33013>:
              check_for_pending_exc.101 = check_for_pending_exc;
              cmethod = mono_marshal_get_native_wrapper (cmethod, check_for_pending_exc.101, 0);
              always = 1;
              <D.33009>:
              D.30408 = cfg->real_offset;
              costs = inline_method (cfg, cmethod, fsig, sp, ip, D.30408, dont_inline, always);
              if (costs != 0) goto <D.33018>; else goto <D.33019>;
              <D.33018>:
              D.30408 = cfg->real_offset;
              D.33020 = D.30408 + 5;
              cfg->real_offset = D.33020;
              bblock.106 = cfg->cbb;
              bblock = bblock.106;
              D.32212 = fsig->ret;
              D.33021 = mono_type_is_void (D.32212);
              if (D.33021 == 0) goto <D.33022>; else goto <D.33023>;
              <D.33022>:
              sp = sp + 8;
              push_res = 0;
              <D.33023>:
              inline_costs = inline_costs + costs;
              goto call_end;
              <D.33019>:
            }
            <D.33007>:
            <D.33004>:
            <D.33001>:
            <D.32990>:
            <D.32995>:
            <D.32992>:
            D.30632 = cfg->opt;
            D.33024 = D.30632 & 4096;
            if (D.33024 != 0) goto <D.33025>; else goto <D.33026>;
            <D.33025>:
            if (call_opcode == 40) goto <D.33027>; else goto <D.33028>;
            <D.33027>:
            if (cmethod == method) goto <D.33029>; else goto <D.33030>;
            <D.33029>:
            D.31664 = ip + 5;
            D.32220 = *D.31664;
            if (D.32220 == 42) goto <D.33031>; else goto <D.33032>;
            <D.33031>:
            if (vtable_arg == 0B) goto <D.33033>; else goto <D.33034>;
            <D.33033>:
            {
              gboolean has_vtargs;
              int i;

              has_vtargs = 0;
              D.30211 = cfg->method;
              if (D.30211 != method) goto <D.33035>; else goto <D.33036>;
              <D.33035>:
              D.30183 = BIT_FIELD_REF <*method, 64, 256>;
              D.30184 = D.30183 & 4467570830351532032;
              if (D.30184 == 0) goto <D.33037>; else goto <D.33038>;
              <D.33037>:
              D.30322 = cfg->verbose_level;
              if (D.30322 > 1) goto <D.33039>; else goto <D.33040>;
              <D.33039>:
              printf ("inline failed: %s\n", "tail call");
              <D.33040>:
              goto inline_failure;
              <D.33038>:
              <D.33036>:
              D.32062 = fsig->param_count;
              D.32063 = (int) D.32062;
              i = D.32063 + -1;
              goto <D.27522>;
              <D.27521>:
              D.33041 = mono_method_signature (cmethod);
              D.33042 = D.33041->params[i];
              D.33043 = mono_type_is_struct (D.33042);
              if (D.33043 != 0) goto <D.33044>; else goto <D.33045>;
              <D.33044>:
              has_vtargs = 1;
              <D.33045>:
              i = i + -1;
              <D.27522>:
              if (i >= 0) goto <D.27521>; else goto <D.27523>;
              <D.27523>:
              if (has_vtargs == 0) goto <D.33046>; else goto <D.33047>;
              <D.33046>:
              i = 0;
              goto <D.27525>;
              <D.27524>:
              D.30241 = cfg->mempool;
              ins = mono_mempool_alloc (D.30241, 80);
              ins->data.op[1].const_val = 0;
              D.30457 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.30457;
              ins->prev = 0B;
              D.30458 = ins->prev;
              ins->next = D.30458;
              ins->opcode = 424;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.30459 = ins->sreg3;
              ins->sreg2 = D.30459;
              D.30460 = ins->sreg2;
              ins->sreg1 = D.30460;
              D.30461 = cfg->ip;
              ins->cil_code = D.30461;
              D.30852 = cfg->arg_types;
              D.33048 = (long unsigned int) i;
              D.33049 = D.33048 * 8;
              D.33050 = D.30852 + D.33049;
              D.33051 = *D.33050;
              D.33052 = mono_type_to_regmove (cfg, D.33051);
              D.33053 = (short unsigned int) D.33052;
              ins->opcode = D.33053;
              D.30842 = cfg->args;
              D.33048 = (long unsigned int) i;
              D.33049 = D.33048 * 8;
              D.33054 = D.30842 + D.33049;
              D.33055 = *D.33054;
              D.33056 = D.33055->klass;
              ins->klass = D.33056;
              D.33048 = (long unsigned int) i;
              D.33049 = D.33048 * 8;
              D.33057 = sp + D.33049;
              D.33058 = *D.33057;
              D.33059 = D.33058->dreg;
              ins->sreg1 = D.33059;
              D.30842 = cfg->args;
              D.33048 = (long unsigned int) i;
              D.33049 = D.33048 * 8;
              D.33054 = D.30842 + D.33049;
              D.33055 = *D.33054;
              D.33060 = D.33055->dreg;
              ins->dreg = D.33060;
              D.30992 = ins->opcode;
              if (D.30992 == 427) goto <D.33061>; else goto <D.33062>;
              <D.33061>:
              D.30852 = cfg->arg_types;
              D.33048 = (long unsigned int) i;
              D.33049 = D.33048 * 8;
              D.33050 = D.30852 + D.33049;
              D.33051 = *D.33050;
              D.33063 = mono_class_from_mono_type (D.33051);
              ins->klass = D.33063;
              <D.33062>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.33064>; else goto <D.33065>;
              <D.33064>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = ins;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              ins->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              goto <D.33066>;
              <D.33065>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.33066>:
              i = i + 1;
              <D.27525>:
              if (i < n) goto <D.27524>; else goto <D.27526>;
              <D.27526>:
              D.30241 = cfg->mempool;
              ins = mono_mempool_alloc (D.30241, 80);
              ins->data.op[1].const_val = 0;
              D.30457 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.30457;
              ins->prev = 0B;
              D.30458 = ins->prev;
              ins->next = D.30458;
              ins->opcode = 442;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.30459 = ins->sreg3;
              ins->sreg2 = D.30459;
              D.30460 = ins->sreg2;
              ins->sreg1 = D.30460;
              D.30461 = cfg->ip;
              ins->cil_code = D.30461;
              bblock.64 = bblock;
              D.30577 = bblock.64->last_ins;
              if (D.30577 != 0B) goto <D.33067>; else goto <D.33068>;
              <D.33067>:
              bblock.64 = bblock;
              D.30577 = bblock.64->last_ins;
              D.30577->next = ins;
              bblock.64 = bblock;
              D.30577 = bblock.64->last_ins;
              ins->prev = D.30577;
              bblock.64 = bblock;
              bblock.64->last_ins = ins;
              goto <D.33069>;
              <D.33068>:
              bblock.64 = bblock;
              bblock.64 = bblock;
              bblock.64->last_ins = ins;
              D.30577 = bblock.64->last_ins;
              bblock.64->code = D.30577;
              <D.33069>:
              D.33070 = start_bblock->out_bb;
              tblock = *D.33070;
              bblock.64 = bblock;
              link_bblock (cfg, bblock.64, tblock);
              ins->data.op[0].target_block = tblock;
              start_new_bblock = 1;
              bblock.64 = bblock;
              D.31664 = ip + 5;
              D.33071 = ip_in_bb (cfg, bblock.64, D.31664);
              if (D.33071 != 0) goto <D.33072>; else goto <D.33073>;
              <D.33072>:
              skip_ret = 1;
              <D.33073>:
              push_res = 0;
              goto call_end;
              <D.33047>:
            }
            <D.33034>:
            <D.33032>:
            <D.33030>:
            <D.33028>:
            <D.33026>:
            num_calls.113 = num_calls;
            num_calls = num_calls.113 + 1;
            D.33075 = num_calls.113 * 10;
            inline_costs = D.33075 + inline_costs;
            if (cmethod != 0B) goto <D.33077>; else goto <D.33076>;
            <D.33077>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.33078>; else goto <D.33076>;
            <D.33078>:
            D.33079 = mini_is_gsharedvt_signature (cfg, fsig);
            if (D.33079 != 0) goto <D.33080>; else goto <D.33076>;
            <D.33080>:
            {
              MonoRgctxInfoType info_type;

              if (virtual != 0) goto <D.33081>; else goto <D.33082>;
              <D.33081>:
              D.32069 = BIT_FIELD_REF <*fsig, 64, 64>;
              D.32361 = D.32069 & 512;
              if (D.32361 != 0) goto <D.33085>; else goto <D.33086>;
              <D.33085>:
              D.30178 = method->klass;
              D.30331 = BIT_FIELD_REF <*D.30178, 64, 256>;
              D.33087 = D.30331 & 2199023255552;
              if (D.33087 != 0) goto <D.33083>; else goto <D.33088>;
              <D.33088>:
              D.30178 = method->klass;
              D.32293 = mono_defaults.object_class;
              if (D.30178 == D.32293) goto <D.33083>; else goto <D.33084>;
              <D.33083>:
              D.30389 = cfg->gsharedvt;
              if (D.30389 != 0) goto <D.33089>; else goto <D.33090>;
              <D.33089>:
              D.30178 = method->klass;
              D.31934 = D.30178->name_space;
              D.30178 = method->klass;
              D.31935 = D.30178->name;
              D.31936 = method->name;
              D.31937 = method->signature;
              D.31938 = D.31937->param_count;
              D.31939 = (int) D.31938;
              D.31121 = *ip;
              D.31122 = (int) D.31121;
              D.33091 = mono_opcode_name (D.31122);
              D.33092 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.31934, D.31935, D.31936, D.31939, D.33091, "method-to-ir.c", 8189);
              cfg->exception_message = D.33092;
              D.30322 = cfg->verbose_level;
              if (D.30322 > 1) goto <D.33093>; else goto <D.33094>;
              <D.33093>:
              D.31944 = cfg->exception_message;
              printf ("%s\n", D.31944);
              <D.33094>:
              mono_cfg_set_exception (cfg, 11);
              goto exception_exit;
              <D.33090>:
              <D.33084>:
              <D.33086>:
              D.32768 = fsig->generic_param_count;
              if (D.32768 != 0) goto <D.33095>; else goto <D.33096>;
              <D.33095>:
              mono_use_imt.114 = mono_use_imt;
              D.33098 = mono_use_imt.114 == 0;
              D.33099 = (long int) D.33098;
              D.33100 = __builtin_expect (D.33099, 0);
              if (D.33100 != 0) goto <D.33101>; else goto <D.33102>;
              <D.33101>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8192, "mono_use_imt");
              <D.33102>:
              D.32798 = imt_arg != 0B;
              D.32799 = (long int) D.32798;
              D.32800 = __builtin_expect (D.32799, 0);
              if (D.32800 != 0) goto <D.33103>; else goto <D.33104>;
              <D.33103>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8193, "!imt_arg");
              <D.33104>:
              imt_arg = emit_get_rgctx_method (cfg, context_used, cmethod, 5);
              vtable_arg = 0B;
              <D.33096>:
              <D.33082>:
              D.32125 = cmethod->klass;
              D.32197 = D.32125->rank;
              if (D.32197 != 0) goto <D.33105>; else goto <D.33106>;
              <D.33105>:
              D.32125 = cmethod->klass;
              D.33107 = D.32125->byval_arg.type;
              if (D.33107 != 29) goto <D.33108>; else goto <D.33109>;
              <D.33108>:
              D.30389 = cfg->gsharedvt;
              if (D.30389 != 0) goto <D.33110>; else goto <D.33111>;
              <D.33110>:
              D.30178 = method->klass;
              D.31934 = D.30178->name_space;
              D.30178 = method->klass;
              D.31935 = D.30178->name;
              D.31936 = method->name;
              D.31937 = method->signature;
              D.31938 = D.31937->param_count;
              D.31939 = (int) D.31938;
              D.31121 = *ip;
              D.31122 = (int) D.31121;
              D.33112 = mono_opcode_name (D.31122);
              D.33113 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.31934, D.31935, D.31936, D.31939, D.33112, "method-to-ir.c", 8204);
              cfg->exception_message = D.33113;
              D.30322 = cfg->verbose_level;
              if (D.30322 > 1) goto <D.33114>; else goto <D.33115>;
              <D.33114>:
              D.31944 = cfg->exception_message;
              printf ("%s\n", D.31944);
              <D.33115>:
              mono_cfg_set_exception (cfg, 11);
              goto exception_exit;
              <D.33111>:
              <D.33109>:
              <D.33106>:
              D.32125 = cmethod->klass;
              D.32590 = D.32125->parent;
              D.32591 = mono_defaults.multicastdelegate_class;
              if (D.32590 == D.32591) goto <D.33116>; else goto <D.33117>;
              <D.33116>:
              D.32594 = cmethod->name;
              D.33118 = strcmp (D.32594, "Invoke");
              if (D.33118 == 0) goto <D.33119>; else goto <D.33120>;
              <D.33119>:
              keep_this_alive = *sp;
              <D.33120>:
              <D.33117>:
              if (virtual != 0) goto <D.33123>; else goto <D.33121>;
              <D.33123>:
              D.32161 = cmethod->flags;
              D.32162 = (int) D.32161;
              D.32696 = D.32162 & 64;
              if (D.32696 != 0) goto <D.33124>; else goto <D.33121>;
              <D.33124>:
              info_type = 17;
              goto <D.33122>;
              <D.33121>:
              info_type = 16;
              <D.33122>:
              addr = emit_get_rgctx_gsharedvt_call (cfg, context_used, fsig, cmethod, info_type);
              ins = mono_emit_calli (cfg, fsig, sp, addr, imt_arg, vtable_arg);
              goto call_end;
            }
            <D.33076>:
            if (calli != 0) goto <D.33125>; else goto <D.33126>;
            <D.33125>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.33127>; else goto <D.33128>;
            <D.33127>:
            D.33129 = mini_is_gsharedvt_signature (cfg, fsig);
            if (D.33129 != 0) goto <D.33130>; else goto <D.33131>;
            <D.33130>:
            {
              struct MonoInst * callee;

              callee = addr;
              D.30183 = BIT_FIELD_REF <*method, 64, 256>;
              D.30184 = D.30183 & 4467570830351532032;
              if (D.30184 != 144115188075855872) goto <D.33132>; else goto <D.33133>;
              <D.33132>:
              D.30389 = cfg->gsharedvt;
              if (D.30389 != 0) goto <D.33134>; else goto <D.33135>;
              <D.33134>:
              D.30178 = method->klass;
              D.31934 = D.30178->name_space;
              D.30178 = method->klass;
              D.31935 = D.30178->name;
              D.31936 = method->name;
              D.31937 = method->signature;
              D.31938 = D.31937->param_count;
              D.31939 = (int) D.31938;
              D.31121 = *ip;
              D.31122 = (int) D.31121;
              D.33136 = mono_opcode_name (D.31122);
              D.33137 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.31934, D.31935, D.31936, D.31939, D.33136, "method-to-ir.c", 8225);
              cfg->exception_message = D.33137;
              D.30322 = cfg->verbose_level;
              if (D.30322 > 1) goto <D.33138>; else goto <D.33139>;
              <D.33138>:
              D.31944 = cfg->exception_message;
              printf ("%s\n", D.31944);
              <D.33139>:
              mono_cfg_set_exception (cfg, 11);
              goto exception_exit;
              <D.33135>:
              <D.33133>:
              addr = emit_get_rgctx_sig (cfg, context_used, fsig, 18);
              ins = mono_emit_calli (cfg, fsig, sp, addr, 0B, callee);
              goto call_end;
            }
            <D.33131>:
            <D.33128>:
            <D.33126>:
            if (context_used != 0) goto <D.33144>; else goto <D.33145>;
            <D.33144>:
            if (imt_arg == 0B) goto <D.33146>; else goto <D.33147>;
            <D.33146>:
            if (array_rank == 0) goto <D.33148>; else goto <D.33149>;
            <D.33148>:
            if (delegate_invoke == 0) goto <D.33150>; else goto <D.33151>;
            <D.33150>:
            D.33152 = mono_method_is_generic_sharable (cmethod, 1);
            if (D.33152 == 0) goto <D.33143>; else goto <D.33153>;
            <D.33153>:
            D.32125 = cmethod->klass;
            D.33154 = mono_class_generic_sharing_enabled (D.32125);
            if (D.33154 == 0) goto <D.33143>; else goto <D.33142>;
            <D.33143>:
            if (virtual == 0) goto <D.33140>; else goto <D.33155>;
            <D.33155>:
            D.32161 = cmethod->flags;
            D.32162 = (int) D.32161;
            D.32698 = D.32162 & 32;
            if (D.32698 != 0) goto <D.33140>; else goto <D.33156>;
            <D.33156>:
            D.32125 = cmethod->klass;
            if (D.32125 != 0B) goto <D.33157>; else goto <D.33141>;
            <D.33157>:
            D.32125 = cmethod->klass;
            D.32304 = D.32125->flags;
            D.32701 = D.32304 & 256;
            if (D.32701 != 0) goto <D.33140>; else goto <D.33141>;
            <D.33141>:
            D.32161 = cmethod->flags;
            D.32162 = (int) D.32161;
            D.32696 = D.32162 & 64;
            if (D.32696 == 0) goto <D.33140>; else goto <D.33142>;
            <D.33140>:
            D.30211 = cfg->method;
            if (D.30211 != method) goto <D.33158>; else goto <D.33159>;
            <D.33158>:
            D.30183 = BIT_FIELD_REF <*method, 64, 256>;
            D.30184 = D.30183 & 4467570830351532032;
            if (D.30184 == 0) goto <D.33160>; else goto <D.33161>;
            <D.33160>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 1) goto <D.33162>; else goto <D.33163>;
            <D.33162>:
            printf ("inline failed: %s\n", "gshared");
            <D.33163>:
            goto inline_failure;
            <D.33161>:
            <D.33159>:
            D.30278 = cfg->generic_sharing_context;
            if (D.30278 == 0B) goto <D.33165>; else goto <D.33168>;
            <D.33168>:
            if (cmethod == 0B) goto <D.33165>; else goto <D.33166>;
            <D.33165>:
            iftmp.115 = 1;
            goto <D.33167>;
            <D.33166>:
            iftmp.115 = 0;
            <D.33167>:
            D.33169 = iftmp.115 != 0;
            D.33170 = (long int) D.33169;
            D.33171 = __builtin_expect (D.33170, 0);
            if (D.33171 != 0) goto <D.33172>; else goto <D.33173>;
            <D.33172>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8243, "cfg->generic_sharing_context && cmethod");
            <D.33173>:
            D.33174 = addr != 0B;
            D.33175 = (long int) D.33174;
            D.33176 = __builtin_expect (D.33175, 0);
            if (D.33176 != 0) goto <D.33177>; else goto <D.33178>;
            <D.33177>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8244, "!addr");
            <D.33178>:
            D.32069 = BIT_FIELD_REF <*fsig, 64, 64>;
            D.32361 = D.32069 & 512;
            if (D.32361 != 0) goto <D.33179>; else goto <D.33180>;
            <D.33179>:
            D.30670 = cfg->flags;
            D.30869 = D.30670 | 128;
            cfg->flags = D.30869;
            D.30229 = BIT_FIELD_REF <*cfg, 64, 5632>;
            D.30870 = D.30229 & 144115188075855872;
            if (D.30870 != 0) goto <D.33181>; else goto <D.33182>;
            <D.33181>:
            D.30229 = BIT_FIELD_REF <*cfg, 64, 5632>;
            D.30870 = D.30229 & 144115188075855872;
            if (D.30870 != 0) goto <D.33183>; else goto <D.33184>;
            <D.33183>:
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.33185 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.33185;
              inst->prev = 0B;
              D.33186 = inst->prev;
              inst->next = D.33186;
              inst->opcode = 323;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.33187 = inst->sreg3;
              inst->sreg2 = D.33187;
              D.33188 = inst->sreg2;
              inst->sreg1 = D.33188;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = -1;
              D.31240 = *sp;
              D.31422 = D.31240->dreg;
              inst->sreg1 = D.31422;
              inst->data.op[1].const_val = 0;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.33189>; else goto <D.33190>;
              <D.33189>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.33191>;
              <D.33190>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.33191>:
            }
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.33192 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.33192;
              inst->prev = 0B;
              D.33193 = inst->prev;
              inst->next = D.33193;
              inst->opcode = 451;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.33194 = inst->sreg3;
              inst->sreg2 = D.33194;
              D.33195 = inst->sreg2;
              inst->sreg1 = D.33195;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->data.op[1].p = "NullReferenceException";
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.33196>; else goto <D.33197>;
              <D.33196>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.33198>;
              <D.33197>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.33198>:
            }
            goto <D.33199>;
            <D.33184>:
            <D.33199>:
            goto <D.33200>;
            <D.33182>:
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.33201 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.33201;
              inst->prev = 0B;
              D.33202 = inst->prev;
              inst->next = D.33202;
              inst->opcode = 340;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.33203 = inst->sreg3;
              inst->sreg2 = D.33203;
              D.33204 = inst->sreg2;
              inst->sreg1 = D.33204;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = -1;
              D.31240 = *sp;
              D.31422 = D.31240->dreg;
              inst->sreg1 = D.31422;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.33205>; else goto <D.33206>;
              <D.33205>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.33207>;
              <D.33206>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.33207>:
            }
            <D.33200>:
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.33208 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.33208;
              inst->prev = 0B;
              D.33209 = inst->prev;
              inst->next = D.33209;
              inst->opcode = 799;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.33210 = inst->sreg3;
              inst->sreg2 = D.33210;
              D.33211 = inst->sreg2;
              inst->sreg1 = D.33211;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = -1;
              D.31240 = *sp;
              D.31422 = D.31240->dreg;
              inst->sreg1 = D.31422;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.33212>; else goto <D.33213>;
              <D.33212>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.33214>;
              <D.33213>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.33214>:
            }
            <D.33180>:
            addr = emit_get_rgctx_method (cfg, context_used, cmethod, 6);
            ins = mono_emit_calli (cfg, fsig, sp, addr, imt_arg, vtable_arg);
            goto call_end;
            <D.33142>:
            <D.33151>:
            <D.33149>:
            <D.33147>:
            <D.33145>:
            if (addr != 0B) goto <D.33215>; else goto <D.33216>;
            <D.33215>:
            if (call_opcode == 40) goto <D.33217>; else goto <D.33218>;
            <D.33217>:
            D.33219 = context_used == 0;
            D.33220 = (long int) D.33219;
            D.33221 = __builtin_expect (D.33220, 0);
            if (D.33221 != 0) goto <D.33222>; else goto <D.33223>;
            <D.33222>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8264, "context_used");
            <D.33223>:
            goto <D.33224>;
            <D.33218>:
            if (call_opcode == 41) goto <D.33225>; else goto <D.33226>;
            <D.33225>:
            D.32681 = vtable_arg != 0B;
            D.32682 = (long int) D.32681;
            D.32683 = __builtin_expect (D.32682, 0);
            if (D.32683 != 0) goto <D.33227>; else goto <D.33228>;
            <D.33227>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8266, "!vtable_arg");
            <D.33228>:
            goto <D.33229>;
            <D.33226>:
            if (0 != 0) goto <D.33230>; else goto <D.33231>;
            <D.33230>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8270, "cmethod->flags & METHOD_ATTRIBUTE_FINAL || !(cmethod->flags & METHOD_ATTRIBUTE_FINAL)");
            <D.33231>:
            <D.33229>:
            <D.33224>:
            D.30211 = cfg->method;
            if (D.30211 != method) goto <D.33232>; else goto <D.33233>;
            <D.33232>:
            D.30183 = BIT_FIELD_REF <*method, 64, 256>;
            D.30184 = D.30183 & 4467570830351532032;
            if (D.30184 == 0) goto <D.33234>; else goto <D.33235>;
            <D.33234>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 1) goto <D.33236>; else goto <D.33237>;
            <D.33236>:
            printf ("inline failed: %s\n", "indirect call");
            <D.33237>:
            goto inline_failure;
            <D.33235>:
            <D.33233>:
            D.33240 = addr->opcode;
            if (D.33240 == 363) goto <D.33238>; else goto <D.33241>;
            <D.33241>:
            D.33240 = addr->opcode;
            if (D.33240 == 732) goto <D.33238>; else goto <D.33242>;
            <D.33242>:
            D.33240 = addr->opcode;
            if (D.33240 == 734) goto <D.33238>; else goto <D.33239>;
            <D.33238>:
            {
              int info_type;
              void * info_data;

              D.33240 = addr->opcode;
              if (D.33240 == 363) goto <D.33243>; else goto <D.33246>;
              <D.33246>:
              D.33240 = addr->opcode;
              if (D.33240 == 732) goto <D.33243>; else goto <D.33244>;
              <D.33243>:
              D.33247 = addr->data.op[1].const_val;
              info_type = (int) D.33247;
              info_data = addr->data.op[0].p;
              goto <D.33245>;
              <D.33244>:
              D.33248 = addr->data.op[1].src;
              D.33249 = D.33248->data.op[1].const_val;
              info_type = (int) D.33249;
              D.33248 = addr->data.op[1].src;
              info_data = D.33248->data.op[0].src;
              <D.33245>:
              info_type.116 = (unsigned int) info_type;
              D.33251 = info_type.116 + 4294967265;
              if (D.33251 <= 1) goto <D.33252>; else goto <D.33253>;
              <D.33252>:
              info_type.117 = (<unnamed type>) info_type;
              ins = mono_emit_abs_call (cfg, info_type.117, info_data, fsig, sp);
              addr->opcode = 316;
              addr->dreg = -1;
              addr->sreg3 = -1;
              D.33255 = addr->sreg3;
              addr->sreg2 = D.33255;
              D.33256 = addr->sreg2;
              addr->sreg1 = D.33256;
              goto call_end;
              <D.33253>:
            }
            <D.33239>:
            ins = mono_emit_calli (cfg, fsig, sp, addr, imt_arg, vtable_arg);
            goto call_end;
            <D.33216>:
            if (array_rank != 0) goto <D.33257>; else goto <D.33258>;
            <D.33257>:
            {
              struct MonoInst * addr;

              D.32594 = cmethod->name;
              D.33259 = strcmp (D.32594, "Set");
              if (D.33259 == 0) goto <D.33260>; else goto <D.33261>;
              <D.33260>:
              {
                struct MonoInst * val;

                D.32062 = fsig->param_count;
                D.32366 = (long unsigned int) D.32062;
                D.32367 = D.32366 * 8;
                D.33262 = sp + D.32367;
                val = *D.33262;
                D.33263 = val->type;
                if (D.33263 == 6) goto <D.33264>; else goto <D.33265>;
                <D.33264>:
                {
                  struct MonoInst * iargs[2];

                  try
                    {
                      D.31240 = *sp;
                      iargs[0] = D.31240;
                      iargs[1] = val;
                      mono_emit_jit_icall (cfg, mono_helper_stelem_ref_check, &iargs);
                    }
                  finally
                    {
                      iargs = {CLOBBER};
                    }
                }
                <D.33265>:
                addr = mini_emit_ldelema_ins (cfg, cmethod, sp, ip, 1);
                D.30241 = cfg->mempool;
                ins = mono_mempool_alloc (D.30241, 80);
                ins->data.op[1].const_val = 0;
                D.30457 = ins->data.op[1].const_val;
                ins->data.op[0].const_val = D.30457;
                ins->prev = 0B;
                D.30458 = ins->prev;
                ins->next = D.30458;
                D.32062 = fsig->param_count;
                D.32063 = (int) D.32062;
                D.33266 = D.32063 + -1;
                D.33267 = fsig->params[D.33266];
                D.33268 = mono_type_to_store_membase (cfg, D.33267);
                D.33269 = (short unsigned int) D.33268;
                ins->opcode = D.33269;
                ins->flags = 0;
                ins->type = 0;
                ins->dreg = -1;
                ins->sreg3 = -1;
                D.30459 = ins->sreg3;
                ins->sreg2 = D.30459;
                D.30460 = ins->sreg2;
                ins->sreg1 = D.30460;
                D.30461 = cfg->ip;
                ins->cil_code = D.30461;
                D.33270 = val->dreg;
                ins->sreg1 = D.33270;
                D.33271 = addr->dreg;
                ins->dreg = D.33271;
                ins->data.op[0].const_val = 0;
                D.32062 = fsig->param_count;
                D.32063 = (int) D.32062;
                D.33266 = D.32063 + -1;
                D.33267 = fsig->params[D.33266];
                type_to_eval_stack_type (cfg, D.33267, ins);
                D.32062 = fsig->param_count;
                D.32063 = (int) D.32062;
                D.33266 = D.32063 + -1;
                D.33267 = fsig->params[D.33266];
                D.33272 = mono_class_from_mono_type (D.33267);
                ins->klass = D.33272;
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                if (D.30490 != 0B) goto <D.33273>; else goto <D.33274>;
                <D.33273>:
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                D.30490->next = ins;
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                ins->prev = D.30490;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = ins;
                goto <D.33275>;
                <D.33274>:
                bblock.106 = cfg->cbb;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = ins;
                D.30490 = bblock.106->last_ins;
                bblock.106->code = D.30490;
                <D.33275>:
                D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
                D.33278 = D.30634 & 8;
                if (D.33278 != 0) goto <D.33279>; else goto <D.33280>;
                <D.33279>:
                D.33263 = val->type;
                if (D.33263 == 6) goto <D.33281>; else goto <D.33282>;
                <D.33281>:
                D.33283 = val->opcode;
                if (D.33283 != 363) goto <D.33276>; else goto <D.33284>;
                <D.33284>:
                D.33285 = val->data.op[0].const_val;
                if (D.33285 != 0) goto <D.33276>; else goto <D.33277>;
                <D.33276>:
                emit_write_barrier (cfg, addr, val);
                <D.33277>:
                <D.33282>:
                <D.33280>:
              }
              goto <D.33286>;
              <D.33261>:
              D.32594 = cmethod->name;
              D.33287 = strcmp (D.32594, "Get");
              if (D.33287 == 0) goto <D.33288>; else goto <D.33289>;
              <D.33288>:
              addr = mini_emit_ldelema_ins (cfg, cmethod, sp, ip, 0);
              D.30241 = cfg->mempool;
              ins = mono_mempool_alloc (D.30241, 80);
              ins->data.op[1].const_val = 0;
              D.30457 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.30457;
              ins->prev = 0B;
              D.30458 = ins->prev;
              ins->next = D.30458;
              D.32212 = fsig->ret;
              D.33290 = mono_type_to_load_membase (cfg, D.32212);
              D.33291 = (short unsigned int) D.33290;
              ins->opcode = D.33291;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.30459 = ins->sreg3;
              ins->sreg2 = D.30459;
              D.30460 = ins->sreg2;
              ins->sreg1 = D.30460;
              D.30461 = cfg->ip;
              ins->cil_code = D.30461;
              ins->dreg = 0;
              D.33271 = addr->dreg;
              ins->sreg1 = D.33271;
              ins->data.op[0].const_val = 0;
              ins->type = 1;
              D.32212 = fsig->ret;
              type_to_eval_stack_type (cfg, D.32212, ins);
              D.30988 = ins->type;
              D.30989 = (<unnamed type>) D.30988;
              D.33292 = alloc_dreg (cfg, D.30989);
              D.33293 = (int) D.33292;
              ins->dreg = D.33293;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.33294>; else goto <D.33295>;
              <D.33294>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = ins;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              ins->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              goto <D.33296>;
              <D.33295>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.33296>:
              goto <D.33297>;
              <D.33289>:
              D.32594 = cmethod->name;
              D.33298 = strcmp (D.32594, "Address");
              if (D.33298 == 0) goto <D.33299>; else goto <D.33300>;
              <D.33299>:
              D.32125 = cmethod->klass;
              D.33301 = D.32125->element_class;
              D.33302 = BIT_FIELD_REF <*D.33301, 64, 256>;
              D.33303 = D.33302 & 1152921504606846976;
              if (D.33303 == 0) goto <D.33304>; else goto <D.33305>;
              <D.33304>:
              if (readonly == 0) goto <D.33306>; else goto <D.33307>;
              <D.33306>:
              D.31240 = *sp;
              D.32125 = cmethod->klass;
              mini_emit_check_array_type (cfg, D.31240, D.32125);
              <D.33307>:
              <D.33305>:
              D.32125 = cmethod->klass;
              if (D.32125 == 0B) goto <D.33308>; else goto <D.33310>;
              <D.33310>:
              D.32125 = cmethod->klass;
              D.32626 = D.32125->exception_type;
              if (D.32626 != 0) goto <D.33308>; else goto <D.33309>;
              <D.33308>:
              D.32125 = cmethod->klass;
              cfg->exception_ptr = D.32125;
              D.33311 = mini_get_debug_options ();
              D.33312 = D.33311->break_on_unverified;
              if (D.33312 != 0) goto <D.33313>; else goto load_error;
              <D.33313>:
              raise (5);
              <D.33309>:
              readonly = 0;
              addr = mini_emit_ldelema_ins (cfg, cmethod, sp, ip, 0);
              ins = addr;
              goto <D.33314>;
              <D.33300>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 8334);
              <D.33314>:
              <D.33297>:
              <D.33286>:
              emit_widen = 0;
              goto call_end;
            }
            <D.33258>:
            if (virtual != 0) goto <D.33316>; else goto <D.33317>;
            <D.33316>:
            iftmp.118 = *sp;
            goto <D.33318>;
            <D.33317>:
            iftmp.118 = 0B;
            <D.33318>:
            ins = mini_redirect_call (cfg, cmethod, fsig, sp, iftmp.118);
            if (ins != 0B) goto call_end; else goto <D.33319>;
            <D.33319>:
            if (cmethod != 0B) goto <D.33320>; else goto <D.33321>;
            <D.33320>:
            D.33322 = ins_flag & 4;
            if (D.33322 != 0) goto <D.33323>; else goto <D.33324>;
            <D.33323>:
            if (vtable_arg == 0B) goto <D.33325>; else goto <D.33326>;
            <D.33325>:
            D.30278 = cfg->generic_sharing_context;
            if (D.30278 == 0B) goto <D.33327>; else goto <D.33328>;
            <D.33327>:
            call_opcode.119 = (int) call_opcode;
            D.33330 = is_supported_tail_call (cfg, method, cmethod, fsig, call_opcode.119);
            if (D.33330 != 0) goto <D.33331>; else goto <D.33332>;
            <D.33331>:
            supported_tail_call = 1;
            <D.33332>:
            <D.33328>:
            <D.33326>:
            <D.33324>:
            <D.33321>:
            if (supported_tail_call != 0) goto <D.33333>; else goto <D.33334>;
            <D.33333>:
            {
              struct MonoCallInst * call;

              D.30211 = cfg->method;
              if (D.30211 != method) goto <D.33335>; else goto <D.33336>;
              <D.33335>:
              D.30183 = BIT_FIELD_REF <*method, 64, 256>;
              D.30184 = D.30183 & 4467570830351532032;
              if (D.30184 == 0) goto <D.33337>; else goto <D.33338>;
              <D.33337>:
              D.30322 = cfg->verbose_level;
              if (D.30322 > 1) goto <D.33339>; else goto <D.33340>;
              <D.33339>:
              printf ("inline failed: %s\n", "tail call");
              <D.33340>:
              goto inline_failure;
              <D.33338>:
              <D.33336>:
              if (0 != 0) goto <D.33341>; else goto <D.33342>;
              <D.33341>:
              tail_call = 1;
              goto <D.33343>;
              <D.33342>:
              D.30241 = cfg->mempool;
              call = mono_mempool_alloc0 (D.30241, 192);
              call->inst.opcode = 443;
              call->inst.dreg = -1;
              call->inst.sreg3 = -1;
              D.33344 = call->inst.sreg3;
              call->inst.sreg2 = D.33344;
              D.33345 = call->inst.sreg2;
              call->inst.sreg1 = D.33345;
              D.30461 = cfg->ip;
              call->inst.cil_code = D.30461;
              call->tail_call = 1;
              call->method = cmethod;
              D.33346 = mono_method_signature (cmethod);
              call->signature = D.33346;
              i = 0;
              goto <D.27540>;
              <D.27539>:
              D.30370 = (long unsigned int) i;
              D.30973 = D.30370 * 8;
              D.32032 = arg_array + D.30973;
              D.32033 = *D.32032;
              D.30370 = (long unsigned int) i;
              D.30973 = D.30370 * 8;
              D.32032 = arg_array + D.30973;
              D.32033 = *D.32032;
              D.32034 = D.32033->flags;
              D.32035 = D.32034 | 4;
              D.32033->flags = D.32035;
              D.30241 = cfg->mempool;
              ins = mono_mempool_alloc (D.30241, 80);
              ins->data.op[1].const_val = 0;
              D.30457 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.30457;
              ins->prev = 0B;
              D.30458 = ins->prev;
              ins->next = D.30458;
              ins->opcode = 424;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.30459 = ins->sreg3;
              ins->sreg2 = D.30459;
              D.30460 = ins->sreg2;
              ins->sreg1 = D.30460;
              D.30461 = cfg->ip;
              ins->cil_code = D.30461;
              D.30852 = cfg->arg_types;
              D.30370 = (long unsigned int) i;
              D.30973 = D.30370 * 8;
              D.33347 = D.30852 + D.30973;
              D.33348 = *D.33347;
              D.33349 = mono_type_to_regmove (cfg, D.33348);
              D.33350 = (short unsigned int) D.33349;
              ins->opcode = D.33350;
              D.30842 = cfg->args;
              D.30370 = (long unsigned int) i;
              D.30973 = D.30370 * 8;
              D.33351 = D.30842 + D.30973;
              D.33352 = *D.33351;
              D.33353 = D.33352->klass;
              ins->klass = D.33353;
              D.30370 = (long unsigned int) i;
              D.30973 = D.30370 * 8;
              D.33354 = sp + D.30973;
              D.33355 = *D.33354;
              D.33356 = D.33355->dreg;
              ins->sreg1 = D.33356;
              D.30842 = cfg->args;
              D.30370 = (long unsigned int) i;
              D.30973 = D.30370 * 8;
              D.33351 = D.30842 + D.30973;
              D.33352 = *D.33351;
              D.33357 = D.33352->dreg;
              ins->dreg = D.33357;
              D.30992 = ins->opcode;
              if (D.30992 == 427) goto <D.33358>; else goto <D.33359>;
              <D.33358>:
              D.30852 = cfg->arg_types;
              D.30370 = (long unsigned int) i;
              D.30973 = D.30370 * 8;
              D.33347 = D.30852 + D.30973;
              D.33348 = *D.33347;
              D.33360 = mono_class_from_mono_type (D.33348);
              ins->klass = D.33360;
              <D.33359>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.33361>; else goto <D.33362>;
              <D.33361>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = ins;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              ins->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              goto <D.33363>;
              <D.33362>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.33363>:
              i = i + 1;
              <D.27540>:
              if (i < n) goto <D.27539>; else goto <D.27541>;
              <D.27541>:
              ins = call;
              ins->data.op[0].p = cmethod;
              D.30550 = *arg_array;
              ins->data.op[1].p = D.30550;
              bblock.64 = bblock;
              D.30577 = bblock.64->last_ins;
              if (D.30577 != 0B) goto <D.33364>; else goto <D.33365>;
              <D.33364>:
              bblock.64 = bblock;
              D.30577 = bblock.64->last_ins;
              D.30577->next = ins;
              bblock.64 = bblock;
              D.30577 = bblock.64->last_ins;
              ins->prev = D.30577;
              bblock.64 = bblock;
              bblock.64->last_ins = ins;
              goto <D.33366>;
              <D.33365>:
              bblock.64 = bblock;
              bblock.64 = bblock;
              bblock.64->last_ins = ins;
              D.30577 = bblock.64->last_ins;
              bblock.64->code = D.30577;
              <D.33366>:
              bblock.64 = bblock;
              link_bblock (cfg, bblock.64, end_bblock);
              start_new_bblock = 1;
              D.30372 = cfg->cil_offset_to_bb;
              D.31664 = ip + 5;
              D.32223 = (long int) D.31664;
              D.30377 = cfg->cil_start;
              D.30378 = (long int) D.30377;
              D.32945 = D.32223 - D.30378;
              D.32946 = (long unsigned int) D.32945;
              D.32947 = D.32946 * 8;
              D.32948 = D.30372 + D.32947;
              tblock = *D.32948;
              if (tblock == 0B) goto <D.33367>; else goto <D.33368>;
              <D.33367>:
              D.31664 = ip + 5;
              if (D.31664 >= end) goto <D.33369>; else goto <D.33371>;
              <D.33371>:
              D.31664 = ip + 5;
              D.30388 = header->code;
              if (D.31664 < D.30388) goto <D.33369>; else goto <D.33370>;
              <D.33369>:
              D.30389 = cfg->gsharedvt;
              if (D.30389 != 0) goto <D.33372>; else goto <D.33373>;
              <D.33372>:
              D.30322 = cfg->verbose_level;
              if (D.30322 > 2) goto <D.33374>; else goto <D.33375>;
              <D.33374>:
              printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
              <D.33375>:
              mono_cfg_set_exception (cfg, 11);
              goto exception_exit;
              <D.33373>:
              D.33376 = mini_get_debug_options ();
              D.33377 = D.33376->break_on_unverified;
              if (D.33377 != 0) goto <D.33378>; else goto unverified;
              <D.33378>:
              raise (5);
              <D.33370>:
              D.30241 = cfg->mempool;
              tblock = mono_mempool_alloc0 (D.30241, 296);
              D.30349 = cfg->num_bblocks;
              D.33379 = D.30349;
              D.33380 = D.33379 + 1;
              cfg->num_bblocks = D.33380;
              D.33381 = (int) D.33379;
              tblock->block_num = D.33381;
              D.31664 = ip + 5;
              tblock->cil_code = D.31664;
              D.30437 = tblock->cil_code;
              if (D.30437 != 0B) goto <D.33382>; else goto <D.33383>;
              <D.33382>:
              D.30372 = cfg->cil_offset_to_bb;
              D.30437 = tblock->cil_code;
              D.30440 = (long int) D.30437;
              D.30377 = cfg->cil_start;
              D.30378 = (long int) D.30377;
              D.30441 = D.30440 - D.30378;
              D.30442 = (long unsigned int) D.30441;
              D.30443 = D.30442 * 8;
              D.30444 = D.30372 + D.30443;
              *D.30444 = tblock;
              <D.33383>:
              D.30408 = cfg->real_offset;
              tblock->real_offset = D.30408;
              <D.33368>:
              bblock.64 = bblock;
              if (tblock == bblock.64) goto <D.33384>; else goto <D.33386>;
              <D.33386>:
              D.33387 = tblock->in_count;
              if (D.33387 == 0) goto <D.33384>; else goto <D.33385>;
              <D.33384>:
              skip_ret = 1;
              <D.33385>:
              push_res = 0;
              goto call_end;
              <D.33343>:
            }
            <D.33334>:
            D.30211 = cfg->method;
            D.32174 = BIT_FIELD_REF <*D.30211, 64, 256>;
            D.32175 = D.32174 & 4467570830351532032;
            if (D.32175 == 2305843009213693952) goto <D.33388>; else goto <D.33389>;
            <D.33388>:
            {
              struct MonoMethod * orig;

              D.30211 = cfg->method;
              orig = mono_marshal_method_from_wrapper (D.30211);
              if (cmethod == orig) goto <D.33390>; else goto <D.33392>;
              <D.33392>:
              D.32245 = BIT_FIELD_REF <*cmethod, 64, 256>;
              D.32805 = D.32245 & 2251799813685248;
              if (D.32805 != 0) goto <D.33393>; else goto <D.33391>;
              <D.33393>:
              D.33394 = mono_method_get_declaring_generic_method (cmethod);
              if (D.33394 == orig) goto <D.33390>; else goto <D.33391>;
              <D.33390>:
              cmethod = mono_marshal_get_synchronized_inner_wrapper (cmethod);
              <D.33391>:
            }
            <D.33389>:
            D.30211 = cfg->method;
            if (D.30211 != method) goto <D.33395>; else goto <D.33396>;
            <D.33395>:
            D.30183 = BIT_FIELD_REF <*method, 64, 256>;
            D.30184 = D.30183 & 4467570830351532032;
            if (D.30184 == 0) goto <D.33397>; else goto <D.33398>;
            <D.33397>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 1) goto <D.33399>; else goto <D.33400>;
            <D.33399>:
            printf ("inline failed: %s\n", "call");
            <D.33400>:
            goto inline_failure;
            <D.33398>:
            <D.33396>:
            if (virtual != 0) goto <D.33402>; else goto <D.33403>;
            <D.33402>:
            iftmp.120 = *sp;
            goto <D.33404>;
            <D.33403>:
            iftmp.120 = 0B;
            <D.33404>:
            ins = mono_emit_method_call_full (cfg, cmethod, fsig, tail_call, sp, iftmp.120, imt_arg, vtable_arg);
            if (tail_call != 0) goto <D.33405>; else goto <D.33406>;
            <D.33405>:
            bblock.64 = bblock;
            link_bblock (cfg, bblock.64, end_bblock);
            start_new_bblock = 1;
            D.30372 = cfg->cil_offset_to_bb;
            D.31664 = ip + 5;
            D.32223 = (long int) D.31664;
            D.30377 = cfg->cil_start;
            D.30378 = (long int) D.30377;
            D.32945 = D.32223 - D.30378;
            D.32946 = (long unsigned int) D.32945;
            D.32947 = D.32946 * 8;
            D.32948 = D.30372 + D.32947;
            tblock = *D.32948;
            if (tblock == 0B) goto <D.33407>; else goto <D.33408>;
            <D.33407>:
            D.31664 = ip + 5;
            if (D.31664 >= end) goto <D.33409>; else goto <D.33411>;
            <D.33411>:
            D.31664 = ip + 5;
            D.30388 = header->code;
            if (D.31664 < D.30388) goto <D.33409>; else goto <D.33410>;
            <D.33409>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.33412>; else goto <D.33413>;
            <D.33412>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.33414>; else goto <D.33415>;
            <D.33414>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.33415>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.33413>:
            D.33416 = mini_get_debug_options ();
            D.33417 = D.33416->break_on_unverified;
            if (D.33417 != 0) goto <D.33418>; else goto unverified;
            <D.33418>:
            raise (5);
            <D.33410>:
            D.30241 = cfg->mempool;
            tblock = mono_mempool_alloc0 (D.30241, 296);
            D.30349 = cfg->num_bblocks;
            D.33419 = D.30349;
            D.33420 = D.33419 + 1;
            cfg->num_bblocks = D.33420;
            D.33421 = (int) D.33419;
            tblock->block_num = D.33421;
            D.31664 = ip + 5;
            tblock->cil_code = D.31664;
            D.30437 = tblock->cil_code;
            if (D.30437 != 0B) goto <D.33422>; else goto <D.33423>;
            <D.33422>:
            D.30372 = cfg->cil_offset_to_bb;
            D.30437 = tblock->cil_code;
            D.30440 = (long int) D.30437;
            D.30377 = cfg->cil_start;
            D.30378 = (long int) D.30377;
            D.30441 = D.30440 - D.30378;
            D.30442 = (long unsigned int) D.30441;
            D.30443 = D.30442 * 8;
            D.30444 = D.30372 + D.30443;
            *D.30444 = tblock;
            <D.33423>:
            D.30408 = cfg->real_offset;
            tblock->real_offset = D.30408;
            <D.33408>:
            bblock.64 = bblock;
            if (tblock == bblock.64) goto <D.33424>; else goto <D.33426>;
            <D.33426>:
            D.33387 = tblock->in_count;
            if (D.33387 == 0) goto <D.33424>; else goto <D.33425>;
            <D.33424>:
            skip_ret = 1;
            <D.33425>:
            push_res = 0;
            <D.33406>:
            call_end:
            if (push_res != 0) goto <D.33427>; else goto <D.33428>;
            <D.33427>:
            D.32212 = fsig->ret;
            D.33429 = mono_type_is_void (D.32212);
            if (D.33429 == 0) goto <D.33430>; else goto <D.33431>;
            <D.33430>:
            D.33432 = ins == 0B;
            D.33433 = (long int) D.33432;
            D.33434 = __builtin_expect (D.33433, 0);
            if (D.33434 != 0) goto <D.33435>; else goto <D.33436>;
            <D.33435>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8442, "ins");
            <D.33436>:
            if (emit_widen != 0) goto <D.33437>; else goto <D.33438>;
            <D.33437>:
            sp.121 = sp;
            sp = sp.121 + 8;
            D.33440 = mono_emit_widen_call_res (cfg, ins, fsig);
            *sp.121 = D.33440;
            goto <D.33441>;
            <D.33438>:
            sp.122 = sp;
            sp = sp.122 + 8;
            *sp.122 = ins;
            <D.33441>:
            <D.33431>:
            <D.33428>:
            if (keep_this_alive != 0B) goto <D.33443>; else goto <D.33444>;
            <D.33443>:
            {
              struct MonoInst * dummy_use;

              D.30241 = cfg->mempool;
              dummy_use = mono_mempool_alloc (D.30241, 80);
              dummy_use->data.op[1].const_val = 0;
              D.33445 = dummy_use->data.op[1].const_val;
              dummy_use->data.op[0].const_val = D.33445;
              dummy_use->prev = 0B;
              D.33446 = dummy_use->prev;
              dummy_use->next = D.33446;
              dummy_use->opcode = 796;
              dummy_use->flags = 0;
              dummy_use->type = 0;
              dummy_use->dreg = -1;
              dummy_use->sreg3 = -1;
              D.33447 = dummy_use->sreg3;
              dummy_use->sreg2 = D.33447;
              D.33448 = dummy_use->sreg2;
              dummy_use->sreg1 = D.33448;
              D.30461 = cfg->ip;
              dummy_use->cil_code = D.30461;
              D.33449 = keep_this_alive->dreg;
              dummy_use->sreg1 = D.33449;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.33450>; else goto <D.33451>;
              <D.33450>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = dummy_use;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              dummy_use->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = dummy_use;
              goto <D.33452>;
              <D.33451>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = dummy_use;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.33452>:
            }
            <D.33444>:
            D.30793 = cfg->exception_type;
            if (D.30793 != 0) goto exception_exit; else goto <D.33453>;
            <D.33453>:
            ip = ip + 5;
            if (skip_ret != 0) goto <D.33454>; else goto <D.33455>;
            <D.33454>:
            D.31121 = *ip;
            D.33456 = D.31121 != 42;
            D.33457 = (long int) D.33456;
            D.33458 = __builtin_expect (D.33457, 0);
            if (D.33458 != 0) goto <D.33459>; else goto <D.33460>;
            <D.33459>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8460, "*ip == CEE_RET");
            <D.33460>:
            ip = ip + 1;
            <D.33455>:
            ins_flag = 0;
            constrained_call = 0B;
            if (need_seq_point != 0) goto <D.33461>; else goto <D.33462>;
            <D.33461>:
            emit_seq_point (cfg, method, ip, 0, 1);
            <D.33462>:
            goto <D.27394>;
          }
        finally
          {
            pass_vtable = {CLOBBER};
            pass_mrgctx = {CLOBBER};
          }
      }
      <D.27544>:
      D.30211 = cfg->method;
      if (D.30211 != method) goto <D.33463>; else goto <D.33464>;
      <D.33463>:
      if (return_var != 0B) goto <D.33465>; else goto <D.33466>;
      <D.33465>:
      bblock.106 = cfg->cbb;
      D.33467 = bblock.106->in_count;
      if (D.33467 != 0) goto <D.33468>; else goto <D.33469>;
      <D.33468>:
      {
        struct MonoType * ret_type;
        struct MonoInst * store;

        D.33470 = mono_method_signature (method);
        ret_type = D.33470->ret;
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        if (D.31013 <= 7) goto <D.33471>; else goto <D.33472>;
        <D.33471>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.33473>; else goto <D.33474>;
        <D.33473>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.33475>; else goto <D.33476>;
        <D.33475>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.33476>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.33474>:
        D.33477 = mini_get_debug_options ();
        D.33478 = D.33477->break_on_unverified;
        if (D.33478 != 0) goto <D.33479>; else goto unverified;
        <D.33479>:
        raise (5);
        <D.33472>:
        sp = sp + 18446744073709551608;
        D.30183 = BIT_FIELD_REF <*method, 64, 256>;
        D.30184 = D.30183 & 4467570830351532032;
        if (D.30184 == 2449958197289549824) goto <D.33480>; else goto <D.33482>;
        <D.33482>:
        D.30183 = BIT_FIELD_REF <*method, 64, 256>;
        D.30184 = D.30183 & 4467570830351532032;
        if (D.30184 == 0) goto <D.33480>; else goto <D.33481>;
        <D.33480>:
        D.31240 = *sp;
        D.33483 = target_type_is_incompatible (cfg, ret_type, D.31240);
        if (D.33483 != 0) goto <D.33484>; else goto <D.33485>;
        <D.33484>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.33486>; else goto <D.33487>;
        <D.33486>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.33488>; else goto <D.33489>;
        <D.33488>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.33489>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.33487>:
        D.33490 = mini_get_debug_options ();
        D.33491 = D.33490->break_on_unverified;
        if (D.33491 != 0) goto <D.33492>; else goto unverified;
        <D.33492>:
        raise (5);
        <D.33485>:
        <D.33481>:
        D.30241 = cfg->mempool;
        store = mono_mempool_alloc (D.30241, 80);
        store->data.op[1].const_val = 0;
        D.33493 = store->data.op[1].const_val;
        store->data.op[0].const_val = D.33493;
        store->prev = 0B;
        D.33494 = store->prev;
        store->next = D.33494;
        store->opcode = 424;
        store->flags = 0;
        store->type = 0;
        store->dreg = -1;
        store->sreg3 = -1;
        D.33495 = store->sreg3;
        store->sreg2 = D.33495;
        D.33496 = store->sreg2;
        store->sreg1 = D.33496;
        D.30461 = cfg->ip;
        store->cil_code = D.30461;
        D.30978 = cfg->varinfo;
        D.33497 = return_var->data.op[0].const_val;
        D.33498 = (long unsigned int) D.33497;
        D.33499 = D.33498 * 8;
        D.33500 = D.30978 + D.33499;
        D.33501 = *D.33500;
        D.33502 = D.33501->data.op[1].vtype;
        D.33503 = mono_type_to_regmove (cfg, D.33502);
        D.33504 = (short unsigned int) D.33503;
        store->opcode = D.33504;
        D.30978 = cfg->varinfo;
        D.33497 = return_var->data.op[0].const_val;
        D.33498 = (long unsigned int) D.33497;
        D.33499 = D.33498 * 8;
        D.33500 = D.30978 + D.33499;
        D.33501 = *D.33500;
        D.33505 = D.33501->klass;
        store->klass = D.33505;
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        store->sreg1 = D.31422;
        D.30978 = cfg->varinfo;
        D.33497 = return_var->data.op[0].const_val;
        D.33498 = (long unsigned int) D.33497;
        D.33499 = D.33498 * 8;
        D.33500 = D.30978 + D.33499;
        D.33501 = *D.33500;
        D.33506 = D.33501->dreg;
        store->dreg = D.33506;
        D.33507 = store->opcode;
        if (D.33507 == 427) goto <D.33508>; else goto <D.33509>;
        <D.33508>:
        D.30978 = cfg->varinfo;
        D.33497 = return_var->data.op[0].const_val;
        D.33498 = (long unsigned int) D.33497;
        D.33499 = D.33498 * 8;
        D.33500 = D.30978 + D.33499;
        D.33501 = *D.33500;
        D.33502 = D.33501->data.op[1].vtype;
        D.33510 = mono_class_from_mono_type (D.33502);
        store->klass = D.33510;
        <D.33509>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.33511>; else goto <D.33512>;
        <D.33511>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = store;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        store->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = store;
        goto <D.33513>;
        <D.33512>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = store;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.33513>:
        cfg->ret_var_set = 1;
      }
      <D.33469>:
      <D.33466>:
      goto <D.33514>;
      <D.33464>:
      D.33515 = cfg->lmf_var;
      if (D.33515 != 0B) goto <D.33516>; else goto <D.33517>;
      <D.33516>:
      bblock.106 = cfg->cbb;
      D.33467 = bblock.106->in_count;
      if (D.33467 != 0) goto <D.33518>; else goto <D.33519>;
      <D.33518>:
      emit_pop_lmf (cfg);
      <D.33519>:
      <D.33517>:
      D.33520 = cfg->ret;
      if (D.33520 != 0B) goto <D.33521>; else goto <D.33522>;
      <D.33521>:
      {
        struct MonoType * ret_type;

        D.33523 = mono_method_signature (method);
        D.33524 = D.33523->ret;
        ret_type = mini_replace_type (D.33524);
        if (seq_points != 0) goto <D.33525>; else goto <D.33526>;
        <D.33525>:
        if (sym_seq_points == 0) goto <D.33527>; else goto <D.33528>;
        <D.33527>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 341;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        ip.69 = (long int) ip;
        D.30388 = header->code;
        D.30933 = (long int) D.30388;
        D.30934 = ip.69 - D.30933;
        ins->data.op[1].const_val = D.30934;
        ins->flags = 1;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.33529>; else goto <D.33530>;
        <D.33529>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.33531>;
        <D.33530>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.33531>:
        <D.33528>:
        <D.33526>:
        D.33532 = return_var != 0B;
        D.33533 = (long int) D.33532;
        D.33534 = __builtin_expect (D.33533, 0);
        if (D.33534 != 0) goto <D.33535>; else goto <D.33536>;
        <D.33535>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 8511, "!return_var");
        <D.33536>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        if (D.31013 <= 7) goto <D.33537>; else goto <D.33538>;
        <D.33537>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.33539>; else goto <D.33540>;
        <D.33539>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.33541>; else goto <D.33542>;
        <D.33541>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.33542>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.33540>:
        D.33543 = mini_get_debug_options ();
        D.33544 = D.33543->break_on_unverified;
        if (D.33544 != 0) goto <D.33545>; else goto unverified;
        <D.33545>:
        raise (5);
        <D.33538>:
        sp = sp + 18446744073709551608;
        D.30183 = BIT_FIELD_REF <*method, 64, 256>;
        D.30184 = D.30183 & 4467570830351532032;
        if (D.30184 == 2449958197289549824) goto <D.33546>; else goto <D.33548>;
        <D.33548>:
        D.30183 = BIT_FIELD_REF <*method, 64, 256>;
        D.30184 = D.30183 & 4467570830351532032;
        if (D.30184 == 0) goto <D.33546>; else goto <D.33547>;
        <D.33546>:
        D.31240 = *sp;
        D.33549 = target_type_is_incompatible (cfg, ret_type, D.31240);
        if (D.33549 != 0) goto <D.33550>; else goto <D.33551>;
        <D.33550>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.33552>; else goto <D.33553>;
        <D.33552>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.33554>; else goto <D.33555>;
        <D.33554>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.33555>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.33553>:
        D.33556 = mini_get_debug_options ();
        D.33557 = D.33556->break_on_unverified;
        if (D.33557 != 0) goto <D.33558>; else goto unverified;
        <D.33558>:
        raise (5);
        <D.33551>:
        <D.33547>:
        D.33559 = mini_type_to_stind (cfg, ret_type);
        if (D.33559 == 129) goto <D.33560>; else goto <D.33561>;
        <D.33560>:
        {
          struct MonoInst * ret_addr;

          D.33562 = cfg->vret_addr;
          if (D.33562 == 0B) goto <D.33563>; else goto <D.33564>;
          <D.33563>:
          {
            struct MonoInst * ins;

            D.30241 = cfg->mempool;
            ins = mono_mempool_alloc (D.30241, 80);
            ins->data.op[1].const_val = 0;
            D.33565 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.33565;
            ins->prev = 0B;
            D.33566 = ins->prev;
            ins->next = D.33566;
            ins->opcode = 424;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.33567 = ins->sreg3;
            ins->sreg2 = D.33567;
            D.33568 = ins->sreg2;
            ins->sreg1 = D.33568;
            D.30461 = cfg->ip;
            ins->cil_code = D.30461;
            D.33569 = mono_type_to_regmove (cfg, ret_type);
            D.33570 = (short unsigned int) D.33569;
            ins->opcode = D.33570;
            D.33520 = cfg->ret;
            D.33571 = D.33520->klass;
            ins->klass = D.33571;
            D.31240 = *sp;
            D.31422 = D.31240->dreg;
            ins->sreg1 = D.31422;
            D.33520 = cfg->ret;
            D.33572 = D.33520->dreg;
            ins->dreg = D.33572;
            D.33573 = ins->opcode;
            if (D.33573 == 427) goto <D.33574>; else goto <D.33575>;
            <D.33574>:
            D.33576 = mono_class_from_mono_type (ret_type);
            ins->klass = D.33576;
            <D.33575>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.33577>; else goto <D.33578>;
            <D.33577>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = ins;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            ins->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            goto <D.33579>;
            <D.33578>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.33579>:
          }
          goto <D.33580>;
          <D.33564>:
          D.30241 = cfg->mempool;
          ret_addr = mono_mempool_alloc (D.30241, 80);
          ret_addr->data.op[1].const_val = 0;
          D.33581 = ret_addr->data.op[1].const_val;
          ret_addr->data.op[0].const_val = D.33581;
          ret_addr->prev = 0B;
          D.33582 = ret_addr->prev;
          ret_addr->next = D.33582;
          ret_addr->opcode = 424;
          ret_addr->flags = 0;
          ret_addr->type = 0;
          ret_addr->dreg = -1;
          ret_addr->sreg3 = -1;
          D.33583 = ret_addr->sreg3;
          ret_addr->sreg2 = D.33583;
          D.33584 = ret_addr->sreg2;
          ret_addr->sreg1 = D.33584;
          D.30461 = cfg->ip;
          ret_addr->cil_code = D.30461;
          ret_addr->type = 5;
          D.33520 = cfg->ret;
          D.33571 = D.33520->klass;
          ret_addr->klass = D.33571;
          D.33562 = cfg->vret_addr;
          D.33585 = D.33562->dreg;
          ret_addr->sreg1 = D.33585;
          D.33586 = ret_addr->type;
          D.33587 = (<unnamed type>) D.33586;
          D.33588 = alloc_dreg (cfg, D.33587);
          D.33589 = (int) D.33588;
          ret_addr->dreg = D.33589;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.33590>; else goto <D.33591>;
          <D.33590>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = ret_addr;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          ret_addr->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ret_addr;
          goto <D.33592>;
          <D.33591>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ret_addr;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.33592>:
          D.30241 = cfg->mempool;
          ins = mono_mempool_alloc (D.30241, 80);
          ins->data.op[1].const_val = 0;
          D.30457 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.30457;
          ins->prev = 0B;
          D.30458 = ins->prev;
          ins->next = D.30458;
          ins->opcode = 387;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.30459 = ins->sreg3;
          ins->sreg2 = D.30459;
          D.30460 = ins->sreg2;
          ins->sreg1 = D.30460;
          D.30461 = cfg->ip;
          ins->cil_code = D.30461;
          D.31240 = *sp;
          D.31422 = D.31240->dreg;
          ins->sreg1 = D.31422;
          D.33593 = ret_addr->dreg;
          ins->dreg = D.33593;
          ins->data.op[0].const_val = 0;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.33594>; else goto <D.33595>;
          <D.33594>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = ins;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          ins->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          goto <D.33596>;
          <D.33595>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.33596>:
          D.33597 = mono_class_from_mono_type (ret_type);
          ins->klass = D.33597;
          <D.33580>:
        }
        goto <D.33598>;
        <D.33561>:
        D.31240 = *sp;
        mono_arch_emit_setret (cfg, method, D.31240);
        <D.33598>:
      }
      <D.33522>:
      <D.33514>:
      if (sp != stack_start) goto <D.33599>; else goto <D.33600>;
      <D.33599>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.33601>; else goto <D.33602>;
      <D.33601>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.33603>; else goto <D.33604>;
      <D.33603>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.33604>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.33602>:
      D.33605 = mini_get_debug_options ();
      D.33606 = D.33605->break_on_unverified;
      if (D.33606 != 0) goto <D.33607>; else goto unverified;
      <D.33607>:
      raise (5);
      <D.33600>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 442;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      ip = ip + 1;
      ins->data.op[0].target_block = end_bblock;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      if (D.30577 != 0B) goto <D.33608>; else goto <D.33609>;
      <D.33608>:
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      D.30577->next = ins;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      ins->prev = D.30577;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      goto <D.33610>;
      <D.33609>:
      bblock.64 = bblock;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      D.30577 = bblock.64->last_ins;
      bblock.64->code = D.30577;
      <D.33610>:
      bblock.64 = bblock;
      link_bblock (cfg, bblock.64, end_bblock);
      start_new_bblock = 1;
      goto <D.27394>;
      <D.27550>:
      D.31251 = ip + 2;
      if (D.31251 > end) goto <D.33611>; else goto <D.33612>;
      <D.33611>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.33613>; else goto <D.33614>;
      <D.33613>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.33615>; else goto <D.33616>;
      <D.33615>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.33616>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.33614>:
      D.33617 = mini_get_debug_options ();
      D.33618 = D.33617->break_on_unverified;
      if (D.33618 != 0) goto <D.33619>; else goto unverified;
      <D.33619>:
      raise (5);
      <D.33612>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 442;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      ip = ip + 1;
      D.31121 = *ip;
      D.33620 = (signed char) D.31121;
      D.33621 = (sizetype) D.33620;
      D.33622 = D.33621 + 1;
      target = ip + D.33622;
      ip = ip + 1;
      D.30372 = cfg->cil_offset_to_bb;
      target.123 = (long int) target;
      D.30377 = cfg->cil_start;
      D.30378 = (long int) D.30377;
      D.33624 = target.123 - D.30378;
      D.33625 = (long unsigned int) D.33624;
      D.33626 = D.33625 * 8;
      D.33627 = D.30372 + D.33626;
      tblock = *D.33627;
      if (tblock == 0B) goto <D.33628>; else goto <D.33629>;
      <D.33628>:
      if (target >= end) goto <D.33630>; else goto <D.33632>;
      <D.33632>:
      D.30388 = header->code;
      if (D.30388 > target) goto <D.33630>; else goto <D.33631>;
      <D.33630>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.33633>; else goto <D.33634>;
      <D.33633>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.33635>; else goto <D.33636>;
      <D.33635>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.33636>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.33634>:
      D.33637 = mini_get_debug_options ();
      D.33638 = D.33637->break_on_unverified;
      if (D.33638 != 0) goto <D.33639>; else goto unverified;
      <D.33639>:
      raise (5);
      <D.33631>:
      D.30241 = cfg->mempool;
      tblock = mono_mempool_alloc0 (D.30241, 296);
      D.30349 = cfg->num_bblocks;
      D.33640 = D.30349;
      D.33641 = D.33640 + 1;
      cfg->num_bblocks = D.33641;
      D.33642 = (int) D.33640;
      tblock->block_num = D.33642;
      tblock->cil_code = target;
      D.30437 = tblock->cil_code;
      if (D.30437 != 0B) goto <D.33643>; else goto <D.33644>;
      <D.33643>:
      D.30372 = cfg->cil_offset_to_bb;
      D.30437 = tblock->cil_code;
      D.30440 = (long int) D.30437;
      D.30377 = cfg->cil_start;
      D.30378 = (long int) D.30377;
      D.30441 = D.30440 - D.30378;
      D.30442 = (long unsigned int) D.30441;
      D.30443 = D.30442 * 8;
      D.30444 = D.30372 + D.30443;
      *D.30444 = tblock;
      <D.33644>:
      D.30408 = cfg->real_offset;
      tblock->real_offset = D.30408;
      <D.33629>:
      bblock.64 = bblock;
      link_bblock (cfg, bblock.64, tblock);
      ins->data.op[0].target_block = tblock;
      if (sp != stack_start) goto <D.33645>; else goto <D.33646>;
      <D.33645>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.31015 = (int) D.31014;
      handle_stack_args (cfg, stack_start, D.31015);
      sp = stack_start;
      D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.31016 = D.30634 & 262144;
      if (D.31016 != 0) goto <D.33647>; else goto <D.33648>;
      <D.33647>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.33649>; else goto <D.33650>;
      <D.33649>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.33651>; else goto <D.33652>;
      <D.33651>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.33652>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.33650>:
      D.33653 = mini_get_debug_options ();
      D.33654 = D.33653->break_on_unverified;
      if (D.33654 != 0) goto <D.33655>; else goto unverified;
      <D.33655>:
      raise (5);
      <D.33648>:
      <D.33646>:
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      if (D.30577 != 0B) goto <D.33656>; else goto <D.33657>;
      <D.33656>:
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      D.30577->next = ins;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      ins->prev = D.30577;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      goto <D.33658>;
      <D.33657>:
      bblock.64 = bblock;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      D.30577 = bblock.64->last_ins;
      bblock.64->code = D.30577;
      <D.33658>:
      start_new_bblock = 1;
      inline_costs = inline_costs + 10;
      goto <D.27394>;
      <D.27551>:
      <D.27552>:
      <D.27553>:
      <D.27554>:
      <D.27555>:
      <D.27556>:
      <D.27557>:
      <D.27558>:
      <D.27559>:
      <D.27560>:
      D.31251 = ip + 2;
      if (D.31251 > end) goto <D.33659>; else goto <D.33660>;
      <D.33659>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.33661>; else goto <D.33662>;
      <D.33661>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.33663>; else goto <D.33664>;
      <D.33663>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.33664>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.33662>:
      D.33665 = mini_get_debug_options ();
      D.33666 = D.33665->break_on_unverified;
      if (D.33666 != 0) goto <D.33667>; else goto unverified;
      <D.33667>:
      raise (5);
      <D.33660>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 15) goto <D.33668>; else goto <D.33669>;
      <D.33668>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.33670>; else goto <D.33671>;
      <D.33670>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.33672>; else goto <D.33673>;
      <D.33672>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.33673>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.33671>:
      D.33674 = mini_get_debug_options ();
      D.33675 = D.33674->break_on_unverified;
      if (D.33675 != 0) goto <D.33676>; else goto unverified;
      <D.33676>:
      raise (5);
      <D.33669>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      D.31121 = *ip;
      D.33677 = (short unsigned int) D.31121;
      D.33678 = D.33677 + 13;
      ins->opcode = D.33678;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      ip = ip + 1;
      D.31656 = MEM[(signed char *)ip];
      D.33679 = (sizetype) D.31656;
      D.33680 = D.33679 + 1;
      target = ip + D.33680;
      ip = ip + 1;
      {
        struct MonoInst * cmp;

        sp = sp + 18446744073709551600;
        D.30241 = cfg->mempool;
        cmp = mono_mempool_alloc (D.30241, 80);
        cmp->data.op[1].const_val = 0;
        D.33681 = cmp->data.op[1].const_val;
        cmp->data.op[0].const_val = D.33681;
        cmp->prev = 0B;
        D.33682 = cmp->prev;
        cmp->next = D.33682;
        cmp->opcode = 322;
        cmp->flags = 0;
        cmp->type = 0;
        cmp->dreg = -1;
        cmp->sreg3 = -1;
        D.33683 = cmp->sreg3;
        cmp->sreg2 = D.33683;
        D.33684 = cmp->sreg2;
        cmp->sreg1 = D.33684;
        D.30461 = cfg->ip;
        cmp->cil_code = D.30461;
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        cmp->sreg1 = D.31422;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        D.32380 = D.32379->dreg;
        cmp->sreg2 = D.32380;
        D.31240 = *sp;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        type_from_op (cmp, D.31240, D.32379);
        D.33685 = cmp->type;
        if (D.33685 == 0) goto <D.33686>; else goto <D.33687>;
        <D.33686>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.33688>; else goto <D.33689>;
        <D.33688>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.33690>; else goto <D.33691>;
        <D.33690>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.33691>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.33689>:
        D.33692 = mini_get_debug_options ();
        D.33693 = D.33692->break_on_unverified;
        if (D.33693 != 0) goto <D.33694>; else goto unverified;
        <D.33694>:
        raise (5);
        <D.33687>:
        D.31240 = *sp;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        type_from_op (ins, D.31240, D.32379);
        D.30241 = cfg->mempool;
        D.33695 = mono_mempool_alloc (D.30241, 16);
        ins->data.op[1].many_blocks = D.33695;
        D.30372 = cfg->cil_offset_to_bb;
        target.123 = (long int) target;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.33624 = target.123 - D.30378;
        D.33625 = (long unsigned int) D.33624;
        D.33626 = D.33625 * 8;
        D.33627 = D.30372 + D.33626;
        tblock = *D.33627;
        if (tblock == 0B) goto <D.33696>; else goto <D.33697>;
        <D.33696>:
        if (target >= end) goto <D.33698>; else goto <D.33700>;
        <D.33700>:
        D.30388 = header->code;
        if (D.30388 > target) goto <D.33698>; else goto <D.33699>;
        <D.33698>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.33701>; else goto <D.33702>;
        <D.33701>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.33703>; else goto <D.33704>;
        <D.33703>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.33704>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.33702>:
        D.33705 = mini_get_debug_options ();
        D.33706 = D.33705->break_on_unverified;
        if (D.33706 != 0) goto <D.33707>; else goto unverified;
        <D.33707>:
        raise (5);
        <D.33699>:
        D.30241 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30241, 296);
        D.30349 = cfg->num_bblocks;
        D.33708 = D.30349;
        D.33709 = D.33708 + 1;
        cfg->num_bblocks = D.33709;
        D.33710 = (int) D.33708;
        tblock->block_num = D.33710;
        tblock->cil_code = target;
        D.30437 = tblock->cil_code;
        if (D.30437 != 0B) goto <D.33711>; else goto <D.33712>;
        <D.33711>:
        D.30372 = cfg->cil_offset_to_bb;
        D.30437 = tblock->cil_code;
        D.30440 = (long int) D.30437;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.30441 = D.30440 - D.30378;
        D.30442 = (long unsigned int) D.30441;
        D.30443 = D.30442 * 8;
        D.30444 = D.30372 + D.30443;
        *D.30444 = tblock;
        <D.33712>:
        D.30408 = cfg->real_offset;
        tblock->real_offset = D.30408;
        <D.33697>:
        bblock.64 = bblock;
        link_bblock (cfg, bblock.64, tblock);
        D.33713 = ins->data.op[1].many_blocks;
        *D.33713 = tblock;
        if (0 != 0) goto <D.33714>; else goto <D.33715>;
        <D.33714>:
        bblock.64 = bblock;
        link_bblock (cfg, bblock.64, 0B);
        D.33713 = ins->data.op[1].many_blocks;
        D.33716 = D.33713 + 8;
        *D.33716 = 0B;
        start_new_bblock = 1;
        goto <D.33717>;
        <D.33715>:
        D.30372 = cfg->cil_offset_to_bb;
        ip.69 = (long int) ip;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.30949 = ip.69 - D.30378;
        D.30950 = (long unsigned int) D.30949;
        D.30951 = D.30950 * 8;
        D.30952 = D.30372 + D.30951;
        tblock = *D.30952;
        if (tblock == 0B) goto <D.33718>; else goto <D.33719>;
        <D.33718>:
        if (ip >= end) goto <D.33720>; else goto <D.33722>;
        <D.33722>:
        D.30388 = header->code;
        if (D.30388 > ip) goto <D.33720>; else goto <D.33721>;
        <D.33720>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.33723>; else goto <D.33724>;
        <D.33723>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.33725>; else goto <D.33726>;
        <D.33725>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.33726>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.33724>:
        D.33727 = mini_get_debug_options ();
        D.33728 = D.33727->break_on_unverified;
        if (D.33728 != 0) goto <D.33729>; else goto unverified;
        <D.33729>:
        raise (5);
        <D.33721>:
        D.30241 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30241, 296);
        D.30349 = cfg->num_bblocks;
        D.33730 = D.30349;
        D.33731 = D.33730 + 1;
        cfg->num_bblocks = D.33731;
        D.33732 = (int) D.33730;
        tblock->block_num = D.33732;
        tblock->cil_code = ip;
        D.30437 = tblock->cil_code;
        if (D.30437 != 0B) goto <D.33733>; else goto <D.33734>;
        <D.33733>:
        D.30372 = cfg->cil_offset_to_bb;
        D.30437 = tblock->cil_code;
        D.30440 = (long int) D.30437;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.30441 = D.30440 - D.30378;
        D.30442 = (long unsigned int) D.30441;
        D.30443 = D.30442 * 8;
        D.30444 = D.30372 + D.30443;
        *D.30444 = tblock;
        <D.33734>:
        D.30408 = cfg->real_offset;
        tblock->real_offset = D.30408;
        <D.33719>:
        bblock.64 = bblock;
        link_bblock (cfg, bblock.64, tblock);
        D.33713 = ins->data.op[1].many_blocks;
        D.33716 = D.33713 + 8;
        *D.33716 = tblock;
        start_new_bblock = 2;
        <D.33717>:
        if (sp != stack_start) goto <D.33735>; else goto <D.33736>;
        <D.33735>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        D.31014 = D.31013 /[ex] 8;
        D.31015 = (int) D.31014;
        handle_stack_args (cfg, stack_start, D.31015);
        D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31016 = D.30634 & 262144;
        if (D.31016 != 0) goto <D.33737>; else goto <D.33738>;
        <D.33737>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.33739>; else goto <D.33740>;
        <D.33739>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.33741>; else goto <D.33742>;
        <D.33741>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.33742>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.33740>:
        D.33743 = mini_get_debug_options ();
        D.33744 = D.33743->break_on_unverified;
        if (D.33744 != 0) goto <D.33745>; else goto unverified;
        <D.33745>:
        raise (5);
        <D.33738>:
        <D.33736>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        if (D.30577 != 0B) goto <D.33746>; else goto <D.33747>;
        <D.33746>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        D.30577->next = cmp;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        cmp->prev = D.30577;
        bblock.64 = bblock;
        bblock.64->last_ins = cmp;
        goto <D.33748>;
        <D.33747>:
        bblock.64 = bblock;
        bblock.64 = bblock;
        bblock.64->last_ins = cmp;
        D.30577 = bblock.64->last_ins;
        bblock.64->code = D.30577;
        <D.33748>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        if (D.30577 != 0B) goto <D.33749>; else goto <D.33750>;
        <D.33749>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        D.30577->next = ins;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        ins->prev = D.30577;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        goto <D.33751>;
        <D.33750>:
        bblock.64 = bblock;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        D.30577 = bblock.64->last_ins;
        bblock.64->code = D.30577;
        <D.33751>:
      }
      sp = stack_start;
      inline_costs = inline_costs + 10;
      goto <D.27394>;
      <D.27562>:
      D.31664 = ip + 5;
      if (D.31664 > end) goto <D.33752>; else goto <D.33753>;
      <D.33752>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.33754>; else goto <D.33755>;
      <D.33754>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.33756>; else goto <D.33757>;
      <D.33756>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.33757>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.33755>:
      D.33758 = mini_get_debug_options ();
      D.33759 = D.33758->break_on_unverified;
      if (D.33759 != 0) goto <D.33760>; else goto unverified;
      <D.33760>:
      raise (5);
      <D.33753>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 442;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      ip = ip + 1;
      D.31797 = MEM[(const guint32 *)ip];
      D.31798 = D.31797 << 24;
      D.31797 = MEM[(const guint32 *)ip];
      D.31799 = D.31797 >> 8;
      D.31800 = D.31799 & 65280;
      D.31801 = D.31798 | D.31800;
      D.31797 = MEM[(const guint32 *)ip];
      D.31802 = D.31797 << 8;
      D.31803 = D.31802 & 16711680;
      D.31804 = D.31801 | D.31803;
      D.31797 = MEM[(const guint32 *)ip];
      D.31805 = D.31797 >> 24;
      D.31806 = D.31804 | D.31805;
      D.33761 = (int) D.31806;
      D.33762 = (sizetype) D.33761;
      D.33763 = D.33762 + 4;
      target = ip + D.33763;
      ip = ip + 4;
      D.30372 = cfg->cil_offset_to_bb;
      target.123 = (long int) target;
      D.30377 = cfg->cil_start;
      D.30378 = (long int) D.30377;
      D.33624 = target.123 - D.30378;
      D.33625 = (long unsigned int) D.33624;
      D.33626 = D.33625 * 8;
      D.33627 = D.30372 + D.33626;
      tblock = *D.33627;
      if (tblock == 0B) goto <D.33764>; else goto <D.33765>;
      <D.33764>:
      if (target >= end) goto <D.33766>; else goto <D.33768>;
      <D.33768>:
      D.30388 = header->code;
      if (D.30388 > target) goto <D.33766>; else goto <D.33767>;
      <D.33766>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.33769>; else goto <D.33770>;
      <D.33769>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.33771>; else goto <D.33772>;
      <D.33771>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.33772>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.33770>:
      D.33773 = mini_get_debug_options ();
      D.33774 = D.33773->break_on_unverified;
      if (D.33774 != 0) goto <D.33775>; else goto unverified;
      <D.33775>:
      raise (5);
      <D.33767>:
      D.30241 = cfg->mempool;
      tblock = mono_mempool_alloc0 (D.30241, 296);
      D.30349 = cfg->num_bblocks;
      D.33776 = D.30349;
      D.33777 = D.33776 + 1;
      cfg->num_bblocks = D.33777;
      D.33778 = (int) D.33776;
      tblock->block_num = D.33778;
      tblock->cil_code = target;
      D.30437 = tblock->cil_code;
      if (D.30437 != 0B) goto <D.33779>; else goto <D.33780>;
      <D.33779>:
      D.30372 = cfg->cil_offset_to_bb;
      D.30437 = tblock->cil_code;
      D.30440 = (long int) D.30437;
      D.30377 = cfg->cil_start;
      D.30378 = (long int) D.30377;
      D.30441 = D.30440 - D.30378;
      D.30442 = (long unsigned int) D.30441;
      D.30443 = D.30442 * 8;
      D.30444 = D.30372 + D.30443;
      *D.30444 = tblock;
      <D.33780>:
      D.30408 = cfg->real_offset;
      tblock->real_offset = D.30408;
      <D.33765>:
      bblock.64 = bblock;
      link_bblock (cfg, bblock.64, tblock);
      ins->data.op[0].target_block = tblock;
      if (sp != stack_start) goto <D.33781>; else goto <D.33782>;
      <D.33781>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.31015 = (int) D.31014;
      handle_stack_args (cfg, stack_start, D.31015);
      sp = stack_start;
      D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.31016 = D.30634 & 262144;
      if (D.31016 != 0) goto <D.33783>; else goto <D.33784>;
      <D.33783>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.33785>; else goto <D.33786>;
      <D.33785>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.33787>; else goto <D.33788>;
      <D.33787>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.33788>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.33786>:
      D.33789 = mini_get_debug_options ();
      D.33790 = D.33789->break_on_unverified;
      if (D.33790 != 0) goto <D.33791>; else goto unverified;
      <D.33791>:
      raise (5);
      <D.33784>:
      <D.33782>:
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      if (D.30577 != 0B) goto <D.33792>; else goto <D.33793>;
      <D.33792>:
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      D.30577->next = ins;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      ins->prev = D.30577;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      goto <D.33794>;
      <D.33793>:
      bblock.64 = bblock;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      D.30577 = bblock.64->last_ins;
      bblock.64->code = D.30577;
      <D.33794>:
      start_new_bblock = 1;
      inline_costs = inline_costs + 10;
      goto <D.27394>;
      <D.27563>:
      <D.27564>:
      <D.27565>:
      <D.27566>:
      {
        struct MonoInst * cmp;
        gboolean is_short;
        gboolean is_true;
        guint32 opsize;

        D.31121 = *ip;
        D.33795 = D.31121 + 212;
        D.33796 = D.33795 <= 1;
        is_short = (gboolean) D.33796;
        D.31121 = *ip;
        if (D.31121 == 45) goto <D.33798>; else goto <D.33801>;
        <D.33801>:
        D.31121 = *ip;
        if (D.31121 == 58) goto <D.33798>; else goto <D.33799>;
        <D.33798>:
        iftmp.124 = 1;
        goto <D.33800>;
        <D.33799>:
        iftmp.124 = 0;
        <D.33800>:
        is_true = iftmp.124;
        if (is_short != 0) goto <D.33803>; else goto <D.33804>;
        <D.33803>:
        iftmp.125 = 1;
        goto <D.33805>;
        <D.33804>:
        iftmp.125 = 4;
        <D.33805>:
        opsize = iftmp.125;
        D.33806 = (sizetype) opsize;
        D.33807 = ip + D.33806;
        if (D.33807 > end) goto <D.33808>; else goto <D.33809>;
        <D.33808>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.33810>; else goto <D.33811>;
        <D.33810>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.33812>; else goto <D.33813>;
        <D.33812>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.33813>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.33811>:
        D.33814 = mini_get_debug_options ();
        D.33815 = D.33814->break_on_unverified;
        if (D.33815 != 0) goto <D.33816>; else goto unverified;
        <D.33816>:
        raise (5);
        <D.33809>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        if (D.31013 <= 7) goto <D.33817>; else goto <D.33818>;
        <D.33817>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.33819>; else goto <D.33820>;
        <D.33819>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.33821>; else goto <D.33822>;
        <D.33821>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.33822>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.33820>:
        D.33823 = mini_get_debug_options ();
        D.33824 = D.33823->break_on_unverified;
        if (D.33824 != 0) goto <D.33825>; else goto unverified;
        <D.33825>:
        raise (5);
        <D.33818>:
        D.33828 = sp + 18446744073709551608;
        D.33829 = *D.33828;
        D.33830 = D.33829->type;
        if (D.33830 == 7) goto <D.33826>; else goto <D.33831>;
        <D.33831>:
        D.33828 = sp + 18446744073709551608;
        D.33829 = *D.33828;
        D.33830 = D.33829->type;
        if (D.33830 == 4) goto <D.33826>; else goto <D.33827>;
        <D.33826>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.33832>; else goto <D.33833>;
        <D.33832>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.33834>; else goto <D.33835>;
        <D.33834>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.33835>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.33833>:
        D.33836 = mini_get_debug_options ();
        D.33837 = D.33836->break_on_unverified;
        if (D.33837 != 0) goto <D.33838>; else goto unverified;
        <D.33838>:
        raise (5);
        <D.33827>:
        ip = ip + 1;
        D.33806 = (sizetype) opsize;
        if (is_short != 0) goto <D.33840>; else goto <D.33841>;
        <D.33840>:
        D.31656 = MEM[(signed char *)ip];
        iftmp.126 = (sizetype) D.31656;
        goto <D.33842>;
        <D.33841>:
        D.31797 = MEM[(const guint32 *)ip];
        D.31798 = D.31797 << 24;
        D.31797 = MEM[(const guint32 *)ip];
        D.31799 = D.31797 >> 8;
        D.31800 = D.31799 & 65280;
        D.31801 = D.31798 | D.31800;
        D.31797 = MEM[(const guint32 *)ip];
        D.31802 = D.31797 << 8;
        D.31803 = D.31802 & 16711680;
        D.31804 = D.31801 | D.31803;
        D.31797 = MEM[(const guint32 *)ip];
        D.31805 = D.31797 >> 24;
        D.31806 = D.31804 | D.31805;
        D.33761 = (int) D.31806;
        iftmp.126 = (sizetype) D.33761;
        <D.33842>:
        D.33843 = D.33806 + iftmp.126;
        target = ip + D.33843;
        D.33806 = (sizetype) opsize;
        ip = ip + D.33806;
        sp = sp + 18446744073709551608;
        D.30372 = cfg->cil_offset_to_bb;
        target.123 = (long int) target;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.33624 = target.123 - D.30378;
        D.33625 = (long unsigned int) D.33624;
        D.33626 = D.33625 * 8;
        D.33627 = D.30372 + D.33626;
        tblock = *D.33627;
        if (tblock == 0B) goto <D.33844>; else goto <D.33845>;
        <D.33844>:
        if (target >= end) goto <D.33846>; else goto <D.33848>;
        <D.33848>:
        D.30388 = header->code;
        if (D.30388 > target) goto <D.33846>; else goto <D.33847>;
        <D.33846>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.33849>; else goto <D.33850>;
        <D.33849>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.33851>; else goto <D.33852>;
        <D.33851>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.33852>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.33850>:
        D.33853 = mini_get_debug_options ();
        D.33854 = D.33853->break_on_unverified;
        if (D.33854 != 0) goto <D.33855>; else goto unverified;
        <D.33855>:
        raise (5);
        <D.33847>:
        D.30241 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30241, 296);
        D.30349 = cfg->num_bblocks;
        D.33856 = D.30349;
        D.33857 = D.33856 + 1;
        cfg->num_bblocks = D.33857;
        D.33858 = (int) D.33856;
        tblock->block_num = D.33858;
        tblock->cil_code = target;
        D.30437 = tblock->cil_code;
        if (D.30437 != 0B) goto <D.33859>; else goto <D.33860>;
        <D.33859>:
        D.30372 = cfg->cil_offset_to_bb;
        D.30437 = tblock->cil_code;
        D.30440 = (long int) D.30437;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.30441 = D.30440 - D.30378;
        D.30442 = (long unsigned int) D.30441;
        D.30443 = D.30442 * 8;
        D.30444 = D.30372 + D.30443;
        *D.30444 = tblock;
        <D.33860>:
        D.30408 = cfg->real_offset;
        tblock->real_offset = D.30408;
        <D.33845>:
        bblock.64 = bblock;
        link_bblock (cfg, bblock.64, tblock);
        D.30372 = cfg->cil_offset_to_bb;
        ip.69 = (long int) ip;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.30949 = ip.69 - D.30378;
        D.30950 = (long unsigned int) D.30949;
        D.30951 = D.30950 * 8;
        D.30952 = D.30372 + D.30951;
        tblock = *D.30952;
        if (tblock == 0B) goto <D.33861>; else goto <D.33862>;
        <D.33861>:
        if (ip >= end) goto <D.33863>; else goto <D.33865>;
        <D.33865>:
        D.30388 = header->code;
        if (D.30388 > ip) goto <D.33863>; else goto <D.33864>;
        <D.33863>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.33866>; else goto <D.33867>;
        <D.33866>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.33868>; else goto <D.33869>;
        <D.33868>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.33869>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.33867>:
        D.33870 = mini_get_debug_options ();
        D.33871 = D.33870->break_on_unverified;
        if (D.33871 != 0) goto <D.33872>; else goto unverified;
        <D.33872>:
        raise (5);
        <D.33864>:
        D.30241 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30241, 296);
        D.30349 = cfg->num_bblocks;
        D.33873 = D.30349;
        D.33874 = D.33873 + 1;
        cfg->num_bblocks = D.33874;
        D.33875 = (int) D.33873;
        tblock->block_num = D.33875;
        tblock->cil_code = ip;
        D.30437 = tblock->cil_code;
        if (D.30437 != 0B) goto <D.33876>; else goto <D.33877>;
        <D.33876>:
        D.30372 = cfg->cil_offset_to_bb;
        D.30437 = tblock->cil_code;
        D.30440 = (long int) D.30437;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.30441 = D.30440 - D.30378;
        D.30442 = (long unsigned int) D.30441;
        D.30443 = D.30442 * 8;
        D.30444 = D.30372 + D.30443;
        *D.30444 = tblock;
        <D.33877>:
        D.30408 = cfg->real_offset;
        tblock->real_offset = D.30408;
        <D.33862>:
        bblock.64 = bblock;
        link_bblock (cfg, bblock.64, tblock);
        if (sp != stack_start) goto <D.33878>; else goto <D.33879>;
        <D.33878>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        D.31014 = D.31013 /[ex] 8;
        D.31015 = (int) D.31014;
        handle_stack_args (cfg, stack_start, D.31015);
        D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31016 = D.30634 & 262144;
        if (D.31016 != 0) goto <D.33880>; else goto <D.33881>;
        <D.33880>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.33882>; else goto <D.33883>;
        <D.33882>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.33884>; else goto <D.33885>;
        <D.33884>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.33885>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.33883>:
        D.33886 = mini_get_debug_options ();
        D.33887 = D.33886->break_on_unverified;
        if (D.33887 != 0) goto <D.33888>; else goto unverified;
        <D.33888>:
        raise (5);
        <D.33881>:
        <D.33879>:
        D.30241 = cfg->mempool;
        cmp = mono_mempool_alloc (D.30241, 80);
        cmp->data.op[1].const_val = 0;
        D.33889 = cmp->data.op[1].const_val;
        cmp->data.op[0].const_val = D.33889;
        cmp->prev = 0B;
        D.33890 = cmp->prev;
        cmp->next = D.33890;
        cmp->opcode = 327;
        cmp->flags = 0;
        cmp->type = 0;
        cmp->dreg = -1;
        cmp->sreg3 = -1;
        D.33891 = cmp->sreg3;
        cmp->sreg2 = D.33891;
        D.33892 = cmp->sreg2;
        cmp->sreg1 = D.33892;
        D.30461 = cfg->ip;
        cmp->cil_code = D.30461;
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        cmp->sreg1 = D.31422;
        D.31240 = *sp;
        type_from_op (cmp, D.31240, 0B);
        D.33893 = cmp->type;
        if (D.33893 == 0) goto <D.33894>; else goto <D.33895>;
        <D.33894>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.33896>; else goto <D.33897>;
        <D.33896>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.33898>; else goto <D.33899>;
        <D.33898>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.33899>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.33897>:
        D.33900 = mini_get_debug_options ();
        D.33901 = D.33900->break_on_unverified;
        if (D.33901 != 0) goto <D.33902>; else goto unverified;
        <D.33902>:
        raise (5);
        <D.33895>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        if (D.30577 != 0B) goto <D.33903>; else goto <D.33904>;
        <D.33903>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        D.30577->next = cmp;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        cmp->prev = D.30577;
        bblock.64 = bblock;
        bblock.64->last_ins = cmp;
        goto <D.33905>;
        <D.33904>:
        bblock.64 = bblock;
        bblock.64 = bblock;
        bblock.64->last_ins = cmp;
        D.30577 = bblock.64->last_ins;
        bblock.64->code = D.30577;
        <D.33905>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        if (is_true != 0) goto <D.33907>; else goto <D.33908>;
        <D.33907>:
        iftmp.127 = 64;
        goto <D.33909>;
        <D.33908>:
        iftmp.127 = 59;
        <D.33909>:
        ins->opcode = iftmp.127;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        D.31240 = *sp;
        type_from_op (ins, D.31240, 0B);
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        if (D.30577 != 0B) goto <D.33910>; else goto <D.33911>;
        <D.33910>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        D.30577->next = ins;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        ins->prev = D.30577;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        goto <D.33912>;
        <D.33911>:
        bblock.64 = bblock;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        D.30577 = bblock.64->last_ins;
        bblock.64->code = D.30577;
        <D.33912>:
        D.30241 = cfg->mempool;
        D.33913 = mono_mempool_alloc (D.30241, 16);
        ins->data.op[1].many_blocks = D.33913;
        D.30372 = cfg->cil_offset_to_bb;
        target.123 = (long int) target;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.33624 = target.123 - D.30378;
        D.33625 = (long unsigned int) D.33624;
        D.33626 = D.33625 * 8;
        D.33627 = D.30372 + D.33626;
        tblock = *D.33627;
        if (tblock == 0B) goto <D.33914>; else goto <D.33915>;
        <D.33914>:
        if (target >= end) goto <D.33916>; else goto <D.33918>;
        <D.33918>:
        D.30388 = header->code;
        if (D.30388 > target) goto <D.33916>; else goto <D.33917>;
        <D.33916>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.33919>; else goto <D.33920>;
        <D.33919>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.33921>; else goto <D.33922>;
        <D.33921>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.33922>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.33920>:
        D.33923 = mini_get_debug_options ();
        D.33924 = D.33923->break_on_unverified;
        if (D.33924 != 0) goto <D.33925>; else goto unverified;
        <D.33925>:
        raise (5);
        <D.33917>:
        D.30241 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30241, 296);
        D.30349 = cfg->num_bblocks;
        D.33926 = D.30349;
        D.33927 = D.33926 + 1;
        cfg->num_bblocks = D.33927;
        D.33928 = (int) D.33926;
        tblock->block_num = D.33928;
        tblock->cil_code = target;
        D.30437 = tblock->cil_code;
        if (D.30437 != 0B) goto <D.33929>; else goto <D.33930>;
        <D.33929>:
        D.30372 = cfg->cil_offset_to_bb;
        D.30437 = tblock->cil_code;
        D.30440 = (long int) D.30437;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.30441 = D.30440 - D.30378;
        D.30442 = (long unsigned int) D.30441;
        D.30443 = D.30442 * 8;
        D.30444 = D.30372 + D.30443;
        *D.30444 = tblock;
        <D.33930>:
        D.30408 = cfg->real_offset;
        tblock->real_offset = D.30408;
        <D.33915>:
        D.33713 = ins->data.op[1].many_blocks;
        *D.33713 = tblock;
        D.30372 = cfg->cil_offset_to_bb;
        ip.69 = (long int) ip;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.30949 = ip.69 - D.30378;
        D.30950 = (long unsigned int) D.30949;
        D.30951 = D.30950 * 8;
        D.30952 = D.30372 + D.30951;
        tblock = *D.30952;
        if (tblock == 0B) goto <D.33931>; else goto <D.33932>;
        <D.33931>:
        if (ip >= end) goto <D.33933>; else goto <D.33935>;
        <D.33935>:
        D.30388 = header->code;
        if (D.30388 > ip) goto <D.33933>; else goto <D.33934>;
        <D.33933>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.33936>; else goto <D.33937>;
        <D.33936>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.33938>; else goto <D.33939>;
        <D.33938>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.33939>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.33937>:
        D.33940 = mini_get_debug_options ();
        D.33941 = D.33940->break_on_unverified;
        if (D.33941 != 0) goto <D.33942>; else goto unverified;
        <D.33942>:
        raise (5);
        <D.33934>:
        D.30241 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30241, 296);
        D.30349 = cfg->num_bblocks;
        D.33943 = D.30349;
        D.33944 = D.33943 + 1;
        cfg->num_bblocks = D.33944;
        D.33945 = (int) D.33943;
        tblock->block_num = D.33945;
        tblock->cil_code = ip;
        D.30437 = tblock->cil_code;
        if (D.30437 != 0B) goto <D.33946>; else goto <D.33947>;
        <D.33946>:
        D.30372 = cfg->cil_offset_to_bb;
        D.30437 = tblock->cil_code;
        D.30440 = (long int) D.30437;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.30441 = D.30440 - D.30378;
        D.30442 = (long unsigned int) D.30441;
        D.30443 = D.30442 * 8;
        D.30444 = D.30372 + D.30443;
        *D.30444 = tblock;
        <D.33947>:
        D.30408 = cfg->real_offset;
        tblock->real_offset = D.30408;
        <D.33932>:
        D.33713 = ins->data.op[1].many_blocks;
        D.33716 = D.33713 + 8;
        *D.33716 = tblock;
        start_new_bblock = 2;
        sp = stack_start;
        inline_costs = inline_costs + 10;
        goto <D.27394>;
      }
      <D.27571>:
      <D.27572>:
      <D.27573>:
      <D.27574>:
      <D.27575>:
      <D.27576>:
      <D.27577>:
      <D.27578>:
      <D.27579>:
      <D.27580>:
      D.31664 = ip + 5;
      if (D.31664 > end) goto <D.33948>; else goto <D.33949>;
      <D.33948>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.33950>; else goto <D.33951>;
      <D.33950>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.33952>; else goto <D.33953>;
      <D.33952>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.33953>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.33951>:
      D.33954 = mini_get_debug_options ();
      D.33955 = D.33954->break_on_unverified;
      if (D.33955 != 0) goto <D.33956>; else goto unverified;
      <D.33956>:
      raise (5);
      <D.33949>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 15) goto <D.33957>; else goto <D.33958>;
      <D.33957>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.33959>; else goto <D.33960>;
      <D.33959>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.33961>; else goto <D.33962>;
      <D.33961>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.33962>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.33960>:
      D.33963 = mini_get_debug_options ();
      D.33964 = D.33963->break_on_unverified;
      if (D.33964 != 0) goto <D.33965>; else goto unverified;
      <D.33965>:
      raise (5);
      <D.33958>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      D.31121 = *ip;
      D.33677 = (short unsigned int) D.31121;
      ins->opcode = D.33677;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      ip = ip + 1;
      D.31797 = MEM[(const guint32 *)ip];
      D.31798 = D.31797 << 24;
      D.31797 = MEM[(const guint32 *)ip];
      D.31799 = D.31797 >> 8;
      D.31800 = D.31799 & 65280;
      D.31801 = D.31798 | D.31800;
      D.31797 = MEM[(const guint32 *)ip];
      D.31802 = D.31797 << 8;
      D.31803 = D.31802 & 16711680;
      D.31804 = D.31801 | D.31803;
      D.31797 = MEM[(const guint32 *)ip];
      D.31805 = D.31797 >> 24;
      D.31806 = D.31804 | D.31805;
      D.33761 = (int) D.31806;
      D.33762 = (sizetype) D.33761;
      D.33763 = D.33762 + 4;
      target = ip + D.33763;
      ip = ip + 4;
      {
        struct MonoInst * cmp;

        sp = sp + 18446744073709551600;
        D.30241 = cfg->mempool;
        cmp = mono_mempool_alloc (D.30241, 80);
        cmp->data.op[1].const_val = 0;
        D.33966 = cmp->data.op[1].const_val;
        cmp->data.op[0].const_val = D.33966;
        cmp->prev = 0B;
        D.33967 = cmp->prev;
        cmp->next = D.33967;
        cmp->opcode = 322;
        cmp->flags = 0;
        cmp->type = 0;
        cmp->dreg = -1;
        cmp->sreg3 = -1;
        D.33968 = cmp->sreg3;
        cmp->sreg2 = D.33968;
        D.33969 = cmp->sreg2;
        cmp->sreg1 = D.33969;
        D.30461 = cfg->ip;
        cmp->cil_code = D.30461;
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        cmp->sreg1 = D.31422;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        D.32380 = D.32379->dreg;
        cmp->sreg2 = D.32380;
        D.31240 = *sp;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        type_from_op (cmp, D.31240, D.32379);
        D.33970 = cmp->type;
        if (D.33970 == 0) goto <D.33971>; else goto <D.33972>;
        <D.33971>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.33973>; else goto <D.33974>;
        <D.33973>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.33975>; else goto <D.33976>;
        <D.33975>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.33976>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.33974>:
        D.33977 = mini_get_debug_options ();
        D.33978 = D.33977->break_on_unverified;
        if (D.33978 != 0) goto <D.33979>; else goto unverified;
        <D.33979>:
        raise (5);
        <D.33972>:
        D.31240 = *sp;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        type_from_op (ins, D.31240, D.32379);
        D.30241 = cfg->mempool;
        D.33980 = mono_mempool_alloc (D.30241, 16);
        ins->data.op[1].many_blocks = D.33980;
        D.30372 = cfg->cil_offset_to_bb;
        target.123 = (long int) target;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.33624 = target.123 - D.30378;
        D.33625 = (long unsigned int) D.33624;
        D.33626 = D.33625 * 8;
        D.33627 = D.30372 + D.33626;
        tblock = *D.33627;
        if (tblock == 0B) goto <D.33981>; else goto <D.33982>;
        <D.33981>:
        if (target >= end) goto <D.33983>; else goto <D.33985>;
        <D.33985>:
        D.30388 = header->code;
        if (D.30388 > target) goto <D.33983>; else goto <D.33984>;
        <D.33983>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.33986>; else goto <D.33987>;
        <D.33986>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.33988>; else goto <D.33989>;
        <D.33988>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.33989>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.33987>:
        D.33990 = mini_get_debug_options ();
        D.33991 = D.33990->break_on_unverified;
        if (D.33991 != 0) goto <D.33992>; else goto unverified;
        <D.33992>:
        raise (5);
        <D.33984>:
        D.30241 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30241, 296);
        D.30349 = cfg->num_bblocks;
        D.33993 = D.30349;
        D.33994 = D.33993 + 1;
        cfg->num_bblocks = D.33994;
        D.33995 = (int) D.33993;
        tblock->block_num = D.33995;
        tblock->cil_code = target;
        D.30437 = tblock->cil_code;
        if (D.30437 != 0B) goto <D.33996>; else goto <D.33997>;
        <D.33996>:
        D.30372 = cfg->cil_offset_to_bb;
        D.30437 = tblock->cil_code;
        D.30440 = (long int) D.30437;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.30441 = D.30440 - D.30378;
        D.30442 = (long unsigned int) D.30441;
        D.30443 = D.30442 * 8;
        D.30444 = D.30372 + D.30443;
        *D.30444 = tblock;
        <D.33997>:
        D.30408 = cfg->real_offset;
        tblock->real_offset = D.30408;
        <D.33982>:
        bblock.64 = bblock;
        link_bblock (cfg, bblock.64, tblock);
        D.33713 = ins->data.op[1].many_blocks;
        *D.33713 = tblock;
        if (0 != 0) goto <D.33998>; else goto <D.33999>;
        <D.33998>:
        bblock.64 = bblock;
        link_bblock (cfg, bblock.64, 0B);
        D.33713 = ins->data.op[1].many_blocks;
        D.33716 = D.33713 + 8;
        *D.33716 = 0B;
        start_new_bblock = 1;
        goto <D.34000>;
        <D.33999>:
        D.30372 = cfg->cil_offset_to_bb;
        ip.69 = (long int) ip;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.30949 = ip.69 - D.30378;
        D.30950 = (long unsigned int) D.30949;
        D.30951 = D.30950 * 8;
        D.30952 = D.30372 + D.30951;
        tblock = *D.30952;
        if (tblock == 0B) goto <D.34001>; else goto <D.34002>;
        <D.34001>:
        if (ip >= end) goto <D.34003>; else goto <D.34005>;
        <D.34005>:
        D.30388 = header->code;
        if (D.30388 > ip) goto <D.34003>; else goto <D.34004>;
        <D.34003>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.34006>; else goto <D.34007>;
        <D.34006>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.34008>; else goto <D.34009>;
        <D.34008>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34009>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34007>:
        D.34010 = mini_get_debug_options ();
        D.34011 = D.34010->break_on_unverified;
        if (D.34011 != 0) goto <D.34012>; else goto unverified;
        <D.34012>:
        raise (5);
        <D.34004>:
        D.30241 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30241, 296);
        D.30349 = cfg->num_bblocks;
        D.34013 = D.30349;
        D.34014 = D.34013 + 1;
        cfg->num_bblocks = D.34014;
        D.34015 = (int) D.34013;
        tblock->block_num = D.34015;
        tblock->cil_code = ip;
        D.30437 = tblock->cil_code;
        if (D.30437 != 0B) goto <D.34016>; else goto <D.34017>;
        <D.34016>:
        D.30372 = cfg->cil_offset_to_bb;
        D.30437 = tblock->cil_code;
        D.30440 = (long int) D.30437;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.30441 = D.30440 - D.30378;
        D.30442 = (long unsigned int) D.30441;
        D.30443 = D.30442 * 8;
        D.30444 = D.30372 + D.30443;
        *D.30444 = tblock;
        <D.34017>:
        D.30408 = cfg->real_offset;
        tblock->real_offset = D.30408;
        <D.34002>:
        bblock.64 = bblock;
        link_bblock (cfg, bblock.64, tblock);
        D.33713 = ins->data.op[1].many_blocks;
        D.33716 = D.33713 + 8;
        *D.33716 = tblock;
        start_new_bblock = 2;
        <D.34000>:
        if (sp != stack_start) goto <D.34018>; else goto <D.34019>;
        <D.34018>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        D.31014 = D.31013 /[ex] 8;
        D.31015 = (int) D.31014;
        handle_stack_args (cfg, stack_start, D.31015);
        D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31016 = D.30634 & 262144;
        if (D.31016 != 0) goto <D.34020>; else goto <D.34021>;
        <D.34020>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.34022>; else goto <D.34023>;
        <D.34022>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.34024>; else goto <D.34025>;
        <D.34024>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34025>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34023>:
        D.34026 = mini_get_debug_options ();
        D.34027 = D.34026->break_on_unverified;
        if (D.34027 != 0) goto <D.34028>; else goto unverified;
        <D.34028>:
        raise (5);
        <D.34021>:
        <D.34019>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        if (D.30577 != 0B) goto <D.34029>; else goto <D.34030>;
        <D.34029>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        D.30577->next = cmp;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        cmp->prev = D.30577;
        bblock.64 = bblock;
        bblock.64->last_ins = cmp;
        goto <D.34031>;
        <D.34030>:
        bblock.64 = bblock;
        bblock.64 = bblock;
        bblock.64->last_ins = cmp;
        D.30577 = bblock.64->last_ins;
        bblock.64->code = D.30577;
        <D.34031>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        if (D.30577 != 0B) goto <D.34032>; else goto <D.34033>;
        <D.34032>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        D.30577->next = ins;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        ins->prev = D.30577;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        goto <D.34034>;
        <D.34033>:
        bblock.64 = bblock;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        D.30577 = bblock.64->last_ins;
        bblock.64->code = D.30577;
        <D.34034>:
      }
      sp = stack_start;
      inline_costs = inline_costs + 10;
      goto <D.27394>;
      <D.27582>:
      {
        struct MonoInst * src1;
        struct MonoBasicBlock * * targets;
        struct MonoBasicBlock * default_bblock;
        struct MonoJumpInfoBBTable * table;
        int offset_reg;
        int target_reg;
        int table_reg;
        int sum_reg;
        gboolean use_op_switch;

        D.34035 = alloc_preg (cfg);
        offset_reg = (int) D.34035;
        D.34036 = alloc_preg (cfg);
        target_reg = (int) D.34036;
        D.34037 = alloc_preg (cfg);
        table_reg = (int) D.34037;
        D.34038 = alloc_preg (cfg);
        sum_reg = (int) D.34038;
        D.31664 = ip + 5;
        if (D.31664 > end) goto <D.34039>; else goto <D.34040>;
        <D.34039>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.34041>; else goto <D.34042>;
        <D.34041>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.34043>; else goto <D.34044>;
        <D.34043>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34044>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34042>:
        D.34045 = mini_get_debug_options ();
        D.34046 = D.34045->break_on_unverified;
        if (D.34046 != 0) goto <D.34047>; else goto unverified;
        <D.34047>:
        raise (5);
        <D.34040>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        if (D.31013 <= 7) goto <D.34048>; else goto <D.34049>;
        <D.34048>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.34050>; else goto <D.34051>;
        <D.34050>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.34052>; else goto <D.34053>;
        <D.34052>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34053>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34051>:
        D.34054 = mini_get_debug_options ();
        D.34055 = D.34054->break_on_unverified;
        if (D.34055 != 0) goto <D.34056>; else goto unverified;
        <D.34056>:
        raise (5);
        <D.34049>:
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31684 = D.31683 << 24;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31685 = D.31683 >> 8;
        D.31686 = D.31685 & 65280;
        D.31687 = D.31684 | D.31686;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31688 = D.31683 << 8;
        D.31689 = D.31688 & 16711680;
        D.31690 = D.31687 | D.31689;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31691 = D.31683 >> 24;
        D.31692 = D.31690 | D.31691;
        n = (int) D.31692;
        sp = sp + 18446744073709551608;
        src1 = *sp;
        D.34057 = src1->type;
        if (D.34057 != 1) goto <D.34058>; else goto <D.34059>;
        <D.34058>:
        D.34057 = src1->type;
        if (D.34057 != 3) goto <D.34060>; else goto <D.34061>;
        <D.34060>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.34062>; else goto <D.34063>;
        <D.34062>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.34064>; else goto <D.34065>;
        <D.34064>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34065>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34063>:
        D.34066 = mini_get_debug_options ();
        D.34067 = D.34066->break_on_unverified;
        if (D.34067 != 0) goto <D.34068>; else goto unverified;
        <D.34068>:
        raise (5);
        <D.34061>:
        <D.34059>:
        ip = ip + 5;
        D.31166 = (long unsigned int) n;
        D.34069 = D.31166 * 4;
        D.34070 = ip + D.34069;
        if (D.34070 > end) goto <D.34071>; else goto <D.34072>;
        <D.34071>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.34073>; else goto <D.34074>;
        <D.34073>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.34075>; else goto <D.34076>;
        <D.34075>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34076>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34074>:
        D.34077 = mini_get_debug_options ();
        D.34078 = D.34077->break_on_unverified;
        if (D.34078 != 0) goto <D.34079>; else goto unverified;
        <D.34079>:
        raise (5);
        <D.34072>:
        D.31166 = (long unsigned int) n;
        D.34069 = D.31166 * 4;
        target = ip + D.34069;
        D.30372 = cfg->cil_offset_to_bb;
        target.123 = (long int) target;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.33624 = target.123 - D.30378;
        D.33625 = (long unsigned int) D.33624;
        D.33626 = D.33625 * 8;
        D.33627 = D.30372 + D.33626;
        default_bblock = *D.33627;
        if (default_bblock == 0B) goto <D.34080>; else goto <D.34081>;
        <D.34080>:
        if (target >= end) goto <D.34082>; else goto <D.34084>;
        <D.34084>:
        D.30388 = header->code;
        if (D.30388 > target) goto <D.34082>; else goto <D.34083>;
        <D.34082>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.34085>; else goto <D.34086>;
        <D.34085>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.34087>; else goto <D.34088>;
        <D.34087>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34088>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34086>:
        D.34089 = mini_get_debug_options ();
        D.34090 = D.34089->break_on_unverified;
        if (D.34090 != 0) goto <D.34091>; else goto unverified;
        <D.34091>:
        raise (5);
        <D.34083>:
        D.30241 = cfg->mempool;
        default_bblock = mono_mempool_alloc0 (D.30241, 296);
        D.30349 = cfg->num_bblocks;
        D.34092 = D.30349;
        D.34093 = D.34092 + 1;
        cfg->num_bblocks = D.34093;
        D.34094 = (int) D.34092;
        default_bblock->block_num = D.34094;
        default_bblock->cil_code = target;
        D.34095 = default_bblock->cil_code;
        if (D.34095 != 0B) goto <D.34096>; else goto <D.34097>;
        <D.34096>:
        D.30372 = cfg->cil_offset_to_bb;
        D.34095 = default_bblock->cil_code;
        D.34098 = (long int) D.34095;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.34099 = D.34098 - D.30378;
        D.34100 = (long unsigned int) D.34099;
        D.34101 = D.34100 * 8;
        D.34102 = D.30372 + D.34101;
        *D.34102 = default_bblock;
        <D.34097>:
        D.30408 = cfg->real_offset;
        default_bblock->real_offset = D.30408;
        <D.34081>:
        D.34103 = default_bblock->flags;
        D.34104 = D.34103 | 32;
        default_bblock->flags = D.34104;
        D.30241 = cfg->mempool;
        D.31166 = (long unsigned int) n;
        D.34105 = (unsigned int) D.31166;
        D.34106 = D.34105 * 8;
        targets = mono_mempool_alloc (D.30241, D.34106);
        i = 0;
        goto <D.27593>;
        <D.27592>:
        D.30372 = cfg->cil_offset_to_bb;
        D.31797 = MEM[(const guint32 *)ip];
        D.31798 = D.31797 << 24;
        D.31797 = MEM[(const guint32 *)ip];
        D.31799 = D.31797 >> 8;
        D.31800 = D.31799 & 65280;
        D.31801 = D.31798 | D.31800;
        D.31797 = MEM[(const guint32 *)ip];
        D.31802 = D.31797 << 8;
        D.31803 = D.31802 & 16711680;
        D.31804 = D.31801 | D.31803;
        D.31797 = MEM[(const guint32 *)ip];
        D.31805 = D.31797 >> 24;
        D.31806 = D.31804 | D.31805;
        D.33761 = (int) D.31806;
        D.33762 = (sizetype) D.33761;
        D.34107 = target + D.33762;
        D.34108 = (long int) D.34107;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.34109 = D.34108 - D.30378;
        D.34110 = (long unsigned int) D.34109;
        D.34111 = D.34110 * 8;
        D.34112 = D.30372 + D.34111;
        tblock = *D.34112;
        if (tblock == 0B) goto <D.34113>; else goto <D.34114>;
        <D.34113>:
        D.31797 = MEM[(const guint32 *)ip];
        D.31798 = D.31797 << 24;
        D.31797 = MEM[(const guint32 *)ip];
        D.31799 = D.31797 >> 8;
        D.31800 = D.31799 & 65280;
        D.31801 = D.31798 | D.31800;
        D.31797 = MEM[(const guint32 *)ip];
        D.31802 = D.31797 << 8;
        D.31803 = D.31802 & 16711680;
        D.31804 = D.31801 | D.31803;
        D.31797 = MEM[(const guint32 *)ip];
        D.31805 = D.31797 >> 24;
        D.31806 = D.31804 | D.31805;
        D.33761 = (int) D.31806;
        D.33762 = (sizetype) D.33761;
        D.34107 = target + D.33762;
        if (D.34107 >= end) goto <D.34115>; else goto <D.34117>;
        <D.34117>:
        D.31797 = MEM[(const guint32 *)ip];
        D.31798 = D.31797 << 24;
        D.31797 = MEM[(const guint32 *)ip];
        D.31799 = D.31797 >> 8;
        D.31800 = D.31799 & 65280;
        D.31801 = D.31798 | D.31800;
        D.31797 = MEM[(const guint32 *)ip];
        D.31802 = D.31797 << 8;
        D.31803 = D.31802 & 16711680;
        D.31804 = D.31801 | D.31803;
        D.31797 = MEM[(const guint32 *)ip];
        D.31805 = D.31797 >> 24;
        D.31806 = D.31804 | D.31805;
        D.33761 = (int) D.31806;
        D.33762 = (sizetype) D.33761;
        D.34107 = target + D.33762;
        D.30388 = header->code;
        if (D.34107 < D.30388) goto <D.34115>; else goto <D.34116>;
        <D.34115>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.34118>; else goto <D.34119>;
        <D.34118>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.34120>; else goto <D.34121>;
        <D.34120>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34121>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34119>:
        D.34122 = mini_get_debug_options ();
        D.34123 = D.34122->break_on_unverified;
        if (D.34123 != 0) goto <D.34124>; else goto unverified;
        <D.34124>:
        raise (5);
        <D.34116>:
        D.30241 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30241, 296);
        D.30349 = cfg->num_bblocks;
        D.34125 = D.30349;
        D.34126 = D.34125 + 1;
        cfg->num_bblocks = D.34126;
        D.34127 = (int) D.34125;
        tblock->block_num = D.34127;
        D.31797 = MEM[(const guint32 *)ip];
        D.31798 = D.31797 << 24;
        D.31797 = MEM[(const guint32 *)ip];
        D.31799 = D.31797 >> 8;
        D.31800 = D.31799 & 65280;
        D.31801 = D.31798 | D.31800;
        D.31797 = MEM[(const guint32 *)ip];
        D.31802 = D.31797 << 8;
        D.31803 = D.31802 & 16711680;
        D.31804 = D.31801 | D.31803;
        D.31797 = MEM[(const guint32 *)ip];
        D.31805 = D.31797 >> 24;
        D.31806 = D.31804 | D.31805;
        D.33761 = (int) D.31806;
        D.33762 = (sizetype) D.33761;
        D.34107 = target + D.33762;
        tblock->cil_code = D.34107;
        D.30437 = tblock->cil_code;
        if (D.30437 != 0B) goto <D.34128>; else goto <D.34129>;
        <D.34128>:
        D.30372 = cfg->cil_offset_to_bb;
        D.30437 = tblock->cil_code;
        D.30440 = (long int) D.30437;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.30441 = D.30440 - D.30378;
        D.30442 = (long unsigned int) D.30441;
        D.30443 = D.30442 * 8;
        D.30444 = D.30372 + D.30443;
        *D.30444 = tblock;
        <D.34129>:
        D.30408 = cfg->real_offset;
        tblock->real_offset = D.30408;
        <D.34114>:
        D.30370 = (long unsigned int) i;
        D.30973 = D.30370 * 8;
        D.34130 = targets + D.30973;
        *D.34130 = tblock;
        D.30370 = (long unsigned int) i;
        D.30973 = D.30370 * 8;
        D.34130 = targets + D.30973;
        D.34131 = *D.34130;
        D.30370 = (long unsigned int) i;
        D.30973 = D.30370 * 8;
        D.34130 = targets + D.30973;
        D.34131 = *D.34130;
        D.34132 = D.34131->flags;
        D.34133 = D.34132 | 32;
        D.34131->flags = D.34133;
        ip = ip + 4;
        i = i + 1;
        <D.27593>:
        if (i < n) goto <D.27592>; else goto <D.27594>;
        <D.27594>:
        if (sp != stack_start) goto <D.34134>; else goto <D.34135>;
        <D.34134>:
        bblock.64 = bblock;
        link_bblock (cfg, bblock.64, default_bblock);
        i = 0;
        goto <D.27596>;
        <D.27595>:
        bblock.64 = bblock;
        D.30370 = (long unsigned int) i;
        D.30973 = D.30370 * 8;
        D.34130 = targets + D.30973;
        D.34131 = *D.34130;
        link_bblock (cfg, bblock.64, D.34131);
        i = i + 1;
        <D.27596>:
        if (i < n) goto <D.27595>; else goto <D.27597>;
        <D.27597>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        D.31014 = D.31013 /[ex] 8;
        D.31015 = (int) D.31014;
        handle_stack_args (cfg, stack_start, D.31015);
        sp = stack_start;
        D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.31016 = D.30634 & 262144;
        if (D.31016 != 0) goto <D.34136>; else goto <D.34137>;
        <D.34136>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.34138>; else goto <D.34139>;
        <D.34138>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.34140>; else goto <D.34141>;
        <D.34140>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34141>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34139>:
        D.34142 = mini_get_debug_options ();
        D.34143 = D.34142->break_on_unverified;
        if (D.34143 != 0) goto <D.34144>; else goto unverified;
        <D.34144>:
        raise (5);
        <D.34137>:
        <D.34135>:
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.34145 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.34145;
          inst->prev = 0B;
          D.34146 = inst->prev;
          inst->next = D.34146;
          inst->opcode = 327;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.34147 = inst->sreg3;
          inst->sreg2 = D.34147;
          D.34148 = inst->sreg2;
          inst->sreg1 = D.34148;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          inst->dreg = -1;
          D.34149 = src1->dreg;
          inst->sreg1 = D.34149;
          D.32275 = (long int) n;
          inst->data.op[1].const_val = D.32275;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.34150>; else goto <D.34151>;
          <D.34150>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.34152>;
          <D.34151>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.34152>:
        }
        {
          struct MonoInst * ins;
          struct MonoBasicBlock * falsebb;

          D.30241 = cfg->mempool;
          ins = mono_mempool_alloc (D.30241, 80);
          ins->data.op[1].const_val = 0;
          D.34153 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.34153;
          ins->prev = 0B;
          D.34154 = ins->prev;
          ins->next = D.34154;
          ins->opcode = 654;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.34155 = ins->sreg3;
          ins->sreg2 = D.34155;
          D.34156 = ins->sreg2;
          ins->sreg1 = D.34156;
          D.30461 = cfg->ip;
          ins->cil_code = D.30461;
          if (0 != 0) goto <D.34157>; else goto <D.34158>;
          <D.34157>:
          D.30241 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.30241, 296);
          D.30349 = cfg->num_bblocks;
          D.34159 = D.30349;
          D.34160 = D.34159 + 1;
          cfg->num_bblocks = D.34160;
          D.34161 = (int) D.34159;
          falsebb->block_num = D.34161;
          ins->data.op[0].target_block = default_bblock;
          bblock.106 = cfg->cbb;
          mono_link_bblock (cfg, bblock.106, default_bblock);
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.34162>; else goto <D.34163>;
          <D.34162>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = ins;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          ins->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          goto <D.34164>;
          <D.34163>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.34164>:
          D.34165 = falsebb->cil_code;
          if (D.34165 != 0B) goto <D.34166>; else goto <D.34167>;
          <D.34166>:
          D.30372 = cfg->cil_offset_to_bb;
          D.34165 = falsebb->cil_code;
          D.34168 = (long int) D.34165;
          D.30377 = cfg->cil_start;
          D.30378 = (long int) D.30377;
          D.34169 = D.34168 - D.30378;
          D.34170 = (long unsigned int) D.34169;
          D.34171 = D.34170 * 8;
          D.34172 = D.30372 + D.34171;
          *D.34172 = falsebb;
          <D.34167>:
          D.30408 = cfg->real_offset;
          falsebb->real_offset = D.30408;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.34176>; else goto <D.34173>;
          <D.34176>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34177 = D.30490->opcode;
          D.34178 = D.34177 + 64985;
          if (D.34178 <= 9) goto <D.34174>; else goto <D.34179>;
          <D.34179>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34177 = D.30490->opcode;
          D.34180 = D.34177 + 64878;
          if (D.34180 <= 9) goto <D.34174>; else goto <D.34181>;
          <D.34181>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34177 = D.30490->opcode;
          D.34182 = D.34177 + 64888;
          if (D.34182 <= 9) goto <D.34174>; else goto <D.34173>;
          <D.34174>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34183 = D.30490->data.op[1].many_blocks;
          D.34184 = D.34183 + 8;
          D.34185 = *D.34184;
          if (D.34185 == 0B) goto <D.34186>; else goto <D.34173>;
          <D.34186>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34183 = D.30490->data.op[1].many_blocks;
          D.34184 = D.34183 + 8;
          *D.34184 = falsebb;
          bblock.106 = cfg->cbb;
          mono_link_bblock (cfg, bblock.106, falsebb);
          goto <D.34175>;
          <D.34173>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 == 0B) goto <D.34187>; else goto <D.34189>;
          <D.34189>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34177 = D.30490->opcode;
          if (D.34177 != 442) goto <D.34190>; else goto <D.34188>;
          <D.34190>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34177 = D.30490->opcode;
          if (D.34177 != 759) goto <D.34191>; else goto <D.34188>;
          <D.34191>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34177 = D.30490->opcode;
          D.34178 = D.34177 + 64985;
          if (D.34178 > 9) goto <D.34192>; else goto <D.34188>;
          <D.34192>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34177 = D.30490->opcode;
          D.34180 = D.34177 + 64878;
          if (D.34180 > 9) goto <D.34193>; else goto <D.34188>;
          <D.34193>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34177 = D.30490->opcode;
          D.34182 = D.34177 + 64888;
          if (D.34182 > 9) goto <D.34187>; else goto <D.34188>;
          <D.34187>:
          bblock.106 = cfg->cbb;
          mono_link_bblock (cfg, bblock.106, falsebb);
          <D.34188>:
          <D.34175>:
          bblock.106 = cfg->cbb;
          bblock.106->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.34194>;
          <D.34158>:
          D.30241 = cfg->mempool;
          D.34195 = mono_mempool_alloc (D.30241, 16);
          ins->data.op[1].many_blocks = D.34195;
          D.34196 = ins->data.op[1].many_blocks;
          *D.34196 = default_bblock;
          D.34196 = ins->data.op[1].many_blocks;
          D.34197 = D.34196 + 8;
          *D.34197 = 0B;
          bblock.106 = cfg->cbb;
          mono_link_bblock (cfg, bblock.106, default_bblock);
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.34198>; else goto <D.34199>;
          <D.34198>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = ins;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          ins->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          goto <D.34200>;
          <D.34199>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.34200>:
          D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.34201 = D.30634 & 268435456;
          if (D.34201 == 0) goto <D.34202>; else goto <D.34203>;
          <D.34202>:
          D.30241 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.30241, 296);
          D.30349 = cfg->num_bblocks;
          D.34204 = D.30349;
          D.34205 = D.34204 + 1;
          cfg->num_bblocks = D.34205;
          D.34206 = (int) D.34204;
          falsebb->block_num = D.34206;
          D.34196 = ins->data.op[1].many_blocks;
          D.34197 = D.34196 + 8;
          *D.34197 = falsebb;
          bblock.106 = cfg->cbb;
          mono_link_bblock (cfg, bblock.106, falsebb);
          D.34165 = falsebb->cil_code;
          if (D.34165 != 0B) goto <D.34207>; else goto <D.34208>;
          <D.34207>:
          D.30372 = cfg->cil_offset_to_bb;
          D.34165 = falsebb->cil_code;
          D.34168 = (long int) D.34165;
          D.30377 = cfg->cil_start;
          D.30378 = (long int) D.30377;
          D.34169 = D.34168 - D.30378;
          D.34170 = (long unsigned int) D.34169;
          D.34171 = D.34170 * 8;
          D.34172 = D.30372 + D.34171;
          *D.34172 = falsebb;
          <D.34208>:
          D.30408 = cfg->real_offset;
          falsebb->real_offset = D.30408;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.34212>; else goto <D.34209>;
          <D.34212>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34177 = D.30490->opcode;
          D.34178 = D.34177 + 64985;
          if (D.34178 <= 9) goto <D.34210>; else goto <D.34213>;
          <D.34213>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34177 = D.30490->opcode;
          D.34180 = D.34177 + 64878;
          if (D.34180 <= 9) goto <D.34210>; else goto <D.34214>;
          <D.34214>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34177 = D.30490->opcode;
          D.34182 = D.34177 + 64888;
          if (D.34182 <= 9) goto <D.34210>; else goto <D.34209>;
          <D.34210>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34183 = D.30490->data.op[1].many_blocks;
          D.34184 = D.34183 + 8;
          D.34185 = *D.34184;
          if (D.34185 == 0B) goto <D.34215>; else goto <D.34209>;
          <D.34215>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34183 = D.30490->data.op[1].many_blocks;
          D.34184 = D.34183 + 8;
          *D.34184 = falsebb;
          bblock.106 = cfg->cbb;
          mono_link_bblock (cfg, bblock.106, falsebb);
          goto <D.34211>;
          <D.34209>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 == 0B) goto <D.34216>; else goto <D.34218>;
          <D.34218>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34177 = D.30490->opcode;
          if (D.34177 != 442) goto <D.34219>; else goto <D.34217>;
          <D.34219>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34177 = D.30490->opcode;
          if (D.34177 != 759) goto <D.34220>; else goto <D.34217>;
          <D.34220>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34177 = D.30490->opcode;
          D.34178 = D.34177 + 64985;
          if (D.34178 > 9) goto <D.34221>; else goto <D.34217>;
          <D.34221>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34177 = D.30490->opcode;
          D.34180 = D.34177 + 64878;
          if (D.34180 > 9) goto <D.34222>; else goto <D.34217>;
          <D.34222>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.34177 = D.30490->opcode;
          D.34182 = D.34177 + 64888;
          if (D.34182 > 9) goto <D.34216>; else goto <D.34217>;
          <D.34216>:
          bblock.106 = cfg->cbb;
          mono_link_bblock (cfg, bblock.106, falsebb);
          <D.34217>:
          <D.34211>:
          bblock.106 = cfg->cbb;
          bblock.106->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.34223>;
          <D.34203>:
          bblock.106 = cfg->cbb;
          bblock.106->extended = 1;
          <D.34223>:
          <D.34194>:
        }
        bblock.106 = cfg->cbb;
        bblock = bblock.106;
        i = 0;
        goto <D.27602>;
        <D.27601>:
        bblock.64 = bblock;
        D.30370 = (long unsigned int) i;
        D.30973 = D.30370 * 8;
        D.34130 = targets + D.30973;
        D.34131 = *D.34130;
        link_bblock (cfg, bblock.64, D.34131);
        i = i + 1;
        <D.27602>:
        if (i < n) goto <D.27601>; else goto <D.27603>;
        <D.27603>:
        D.30241 = cfg->mempool;
        table = mono_mempool_alloc (D.30241, 16);
        table->table = targets;
        table->table_size = n;
        use_op_switch = 0;
        if (0 != 0) goto <D.34224>; else goto <D.34225>;
        <D.34224>:
        use_op_switch = 1;
        <D.34225>:
        bblock.106 = cfg->cbb;
        bblock.106->has_jump_table = 1;
        if (use_op_switch != 0) goto <D.34226>; else goto <D.34227>;
        <D.34226>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 370;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        D.34149 = src1->dreg;
        ins->sreg1 = D.34149;
        ins->data.op[0].p = table;
        ins->data.op[1].many_blocks = targets;
        D.31166 = (long unsigned int) n;
        D.34228 = (struct MonoClass *) D.31166;
        ins->klass = D.34228;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.34229>; else goto <D.34230>;
        <D.34229>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.34231>;
        <D.34230>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.34231>:
        goto <D.34232>;
        <D.34227>:
        if (1 != 0) goto <D.34233>; else goto <D.34234>;
        <D.34233>:
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.34235 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.34235;
          inst->prev = 0B;
          D.34236 = inst->prev;
          inst->next = D.34236;
          inst->opcode = 439;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.34237 = inst->sreg3;
          inst->sreg2 = D.34237;
          D.34238 = inst->sreg2;
          inst->sreg1 = D.34238;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          inst->dreg = offset_reg;
          D.34149 = src1->dreg;
          inst->sreg1 = D.34149;
          inst->data.op[1].const_val = 3;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.34239>; else goto <D.34240>;
          <D.34239>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.34241>;
          <D.34240>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.34241>:
        }
        goto <D.34242>;
        <D.34234>:
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.34243 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.34243;
          inst->prev = 0B;
          D.34244 = inst->prev;
          inst->next = D.34244;
          inst->opcode = 439;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.34245 = inst->sreg3;
          inst->sreg2 = D.34245;
          D.34246 = inst->sreg2;
          inst->sreg1 = D.34246;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          inst->dreg = offset_reg;
          D.34149 = src1->dreg;
          inst->sreg1 = D.34149;
          inst->data.op[1].const_val = 2;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.34247>; else goto <D.34248>;
          <D.34247>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.34249>;
          <D.34248>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.34249>:
        }
        <D.34242>:
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.34250 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.34250;
          inst->prev = 0B;
          D.34251 = inst->prev;
          inst->next = D.34251;
          inst->opcode = 765;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.34252 = inst->sreg3;
          inst->sreg2 = D.34252;
          D.34253 = inst->sreg2;
          inst->sreg1 = D.34253;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          inst->dreg = offset_reg;
          inst->sreg1 = offset_reg;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.34254>; else goto <D.34255>;
          <D.34254>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.34256>;
          <D.34255>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.34256>:
        }
        D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.30635 = D.30634 & 33554432;
        if (D.30635 != 0) goto <D.34257>; else goto <D.34258>;
        <D.34257>:
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.34259 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.34259;
          inst->prev = 0B;
          D.34260 = inst->prev;
          inst->next = D.34260;
          D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.30635 = D.30634 & 33554432;
          if (D.30635 != 0) goto <D.34262>; else goto <D.34263>;
          <D.34262>:
          iftmp.128 = 732;
          goto <D.34264>;
          <D.34263>:
          iftmp.128 = 363;
          <D.34264>:
          inst->opcode = iftmp.128;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.34265 = inst->sreg3;
          inst->sreg2 = D.34265;
          D.34266 = inst->sreg2;
          inst->sreg1 = D.34266;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          inst->dreg = table_reg;
          inst->data.op[0].p = table;
          inst->data.op[1].const_val = 8;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.34267>; else goto <D.34268>;
          <D.34267>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.34269>;
          <D.34268>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.34269>:
        }
        goto <D.34270>;
        <D.34258>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 731;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        ins->data.op[1].const_val = 8;
        ins->data.op[0].p = table;
        ins->dreg = table_reg;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.34271>; else goto <D.34272>;
        <D.34271>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.34273>;
        <D.34272>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.34273>:
        <D.34270>:
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.34274 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.34274;
          inst->prev = 0B;
          D.34275 = inst->prev;
          inst->next = D.34275;
          inst->opcode = 479;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.34276 = inst->sreg3;
          inst->sreg2 = D.34276;
          D.34277 = inst->sreg2;
          inst->sreg1 = D.34277;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          inst->dreg = sum_reg;
          inst->sreg1 = table_reg;
          inst->sreg2 = offset_reg;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.34278>; else goto <D.34279>;
          <D.34278>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.34280>;
          <D.34279>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.34280>:
        }
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.34281 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.34281;
          inst->prev = 0B;
          D.34282 = inst->prev;
          inst->next = D.34282;
          inst->opcode = 388;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.34283 = inst->sreg3;
          inst->sreg2 = D.34283;
          D.34284 = inst->sreg2;
          inst->sreg1 = D.34284;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          inst->dreg = target_reg;
          inst->sreg1 = sum_reg;
          inst->data.op[0].const_val = 0;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.34285>; else goto <D.34286>;
          <D.34285>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.34287>;
          <D.34286>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.34287>:
        }
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.34288 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.34288;
          inst->prev = 0B;
          D.34289 = inst->prev;
          inst->next = D.34289;
          inst->opcode = 759;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.34290 = inst->sreg3;
          inst->sreg2 = D.34290;
          D.34291 = inst->sreg2;
          inst->sreg1 = D.34291;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          inst->dreg = -1;
          inst->sreg1 = target_reg;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.34292>; else goto <D.34293>;
          <D.34292>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.34294>;
          <D.34293>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.34294>:
        }
        <D.34232>:
        start_new_bblock = 1;
        inline_costs = inline_costs + 20;
        goto <D.27394>;
      }
      <D.27611>:
      <D.27612>:
      <D.27613>:
      <D.27614>:
      <D.27615>:
      <D.27616>:
      <D.27617>:
      <D.27618>:
      <D.27619>:
      <D.27620>:
      <D.27621>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.34295>; else goto <D.34296>;
      <D.34295>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34297>; else goto <D.34298>;
      <D.34297>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34299>; else goto <D.34300>;
      <D.34299>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34300>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34298>:
      D.34301 = mini_get_debug_options ();
      D.34302 = D.34301->break_on_unverified;
      if (D.34302 != 0) goto <D.34303>; else goto unverified;
      <D.34303>:
      raise (5);
      <D.34296>:
      sp = sp + 18446744073709551608;
      D.31121 = *ip;
      D.31122 = (int) D.31121;
      switch (D.31122) <default: <D.27627>, case 76: <D.27625>, case 78: <D.27622>, case 79: <D.27623>, case 80: <D.27626>>
      <D.27622>:
      <D.27623>:
      D.34304 = alloc_freg (cfg);
      dreg = (int) D.34304;
      goto <D.27624>;
      <D.27625>:
      D.34305 = alloc_lreg (cfg);
      dreg = (int) D.34305;
      goto <D.27624>;
      <D.27626>:
      D.34306 = alloc_ireg_ref (cfg);
      dreg = (int) D.34306;
      goto <D.27624>;
      <D.27627>:
      D.34307 = alloc_preg (cfg);
      dreg = (int) D.34307;
      <D.27624>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      D.31121 = *ip;
      D.31122 = (int) D.31121;
      D.34308 = ldind_to_load_membase (D.31122);
      D.34309 = (short unsigned int) D.34308;
      ins->opcode = D.34309;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      ins->dreg = dreg;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      ins->data.op[0].const_val = 0;
      ins->type = 1;
      D.31121 = *ip;
      D.31122 = (int) D.31121;
      D.34310 = D.31122 + -70;
      D.34311 = ldind_type[D.34310];
      ins->type = D.34311;
      D.31088 = ins->flags;
      D.34312 = (unsigned char) ins_flag;
      D.34313 = D.31088 | D.34312;
      ins->flags = D.34313;
      ins_flag = 0;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      if (D.30577 != 0B) goto <D.34314>; else goto <D.34315>;
      <D.34314>:
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      D.30577->next = ins;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      ins->prev = D.30577;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      goto <D.34316>;
      <D.34315>:
      bblock.64 = bblock;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      D.30577 = bblock.64->last_ins;
      bblock.64->code = D.30577;
      <D.34316>:
      sp.129 = sp;
      sp = sp.129 + 8;
      *sp.129 = ins;
      D.31088 = ins->flags;
      D.34318 = (int) D.31088;
      D.34319 = D.34318 & 4;
      if (D.34319 != 0) goto <D.34320>; else goto <D.34321>;
      <D.34320>:
      emit_memory_barrier (cfg, 4);
      <D.34321>:
      ip = ip + 1;
      goto <D.27394>;
      <D.27628>:
      <D.27629>:
      <D.27630>:
      <D.27631>:
      <D.27632>:
      <D.27633>:
      <D.27634>:
      <D.27635>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 15) goto <D.34322>; else goto <D.34323>;
      <D.34322>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34324>; else goto <D.34325>;
      <D.34324>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34326>; else goto <D.34327>;
      <D.34326>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34327>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34325>:
      D.34328 = mini_get_debug_options ();
      D.34329 = D.34328->break_on_unverified;
      if (D.34329 != 0) goto <D.34330>; else goto unverified;
      <D.34330>:
      raise (5);
      <D.34323>:
      sp = sp + 18446744073709551600;
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      D.31121 = *ip;
      D.31122 = (int) D.31121;
      D.34331 = stind_to_store_membase (D.31122);
      D.34332 = (short unsigned int) D.34331;
      ins->opcode = D.34332;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      D.32380 = D.32379->dreg;
      ins->sreg1 = D.32380;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->dreg = D.31422;
      ins->data.op[0].const_val = 0;
      D.31088 = ins->flags;
      D.34312 = (unsigned char) ins_flag;
      D.34313 = D.31088 | D.34312;
      ins->flags = D.34313;
      ins_flag = 0;
      D.31088 = ins->flags;
      D.34318 = (int) D.31088;
      D.34319 = D.34318 & 4;
      if (D.34319 != 0) goto <D.34333>; else goto <D.34334>;
      <D.34333>:
      emit_memory_barrier (cfg, 4);
      <D.34334>:
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      if (D.30577 != 0B) goto <D.34335>; else goto <D.34336>;
      <D.34335>:
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      D.30577->next = ins;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      ins->prev = D.30577;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      goto <D.34337>;
      <D.34336>:
      bblock.64 = bblock;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      D.30577 = bblock.64->last_ins;
      bblock.64->code = D.30577;
      <D.34337>:
      D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.33278 = D.30634 & 8;
      if (D.33278 != 0) goto <D.34340>; else goto <D.34341>;
      <D.34340>:
      D.31121 = *ip;
      if (D.31121 == 81) goto <D.34342>; else goto <D.34343>;
      <D.34342>:
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30184 = D.30183 & 4467570830351532032;
      if (D.30184 != 3458764513820540928) goto <D.34344>; else goto <D.34345>;
      <D.34344>:
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      D.34346 = D.32379->opcode;
      if (D.34346 != 363) goto <D.34338>; else goto <D.34347>;
      <D.34347>:
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      D.34348 = D.32379->data.op[0].p;
      if (D.34348 != 0B) goto <D.34338>; else goto <D.34339>;
      <D.34338>:
      D.31240 = *sp;
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      emit_write_barrier (cfg, D.31240, D.32379);
      <D.34339>:
      <D.34345>:
      <D.34343>:
      <D.34341>:
      inline_costs = inline_costs + 1;
      ip = ip + 1;
      goto <D.27394>;
      <D.27636>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 15) goto <D.34349>; else goto <D.34350>;
      <D.34349>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34351>; else goto <D.34352>;
      <D.34351>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34353>; else goto <D.34354>;
      <D.34353>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34354>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34352>:
      D.34355 = mini_get_debug_options ();
      D.34356 = D.34355->break_on_unverified;
      if (D.34356 != 0) goto <D.34357>; else goto unverified;
      <D.34357>:
      raise (5);
      <D.34350>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      D.31121 = *ip;
      D.33677 = (short unsigned int) D.31121;
      ins->opcode = D.33677;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      sp = sp + 18446744073709551600;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      D.32380 = D.32379->dreg;
      ins->sreg2 = D.32380;
      D.31240 = *sp;
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      type_from_op (ins, D.31240, D.32379);
      D.30988 = ins->type;
      if (D.30988 == 0) goto <D.34358>; else goto <D.34359>;
      <D.34358>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34360>; else goto <D.34361>;
      <D.34360>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34362>; else goto <D.34363>;
      <D.34362>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34363>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34361>:
      D.34364 = mini_get_debug_options ();
      D.34365 = D.34364->break_on_unverified;
      if (D.34365 != 0) goto <D.34366>; else goto unverified;
      <D.34366>:
      raise (5);
      <D.34359>:
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.34367 = alloc_dreg (cfg, D.30989);
      D.34368 = (int) D.34367;
      ins->dreg = D.34368;
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      D.34346 = D.32379->opcode;
      if (D.34346 == 362) goto <D.34369>; else goto <D.34370>;
      <D.34369>:
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      D.34371 = D.32379->data.op[0].const_val;
      D.34372 = mono_arch_is_inst_imm (D.34371);
      if (D.34372 != 0) goto <D.34373>; else goto <D.34374>;
      <D.34373>:
      {
        int imm_opcode;

        D.30992 = ins->opcode;
        D.34375 = (int) D.30992;
        imm_opcode = mono_op_to_op_imm_noemul (D.34375);
        if (imm_opcode != -1) goto <D.34376>; else goto <D.34377>;
        <D.34376>:
        D.34378 = (short unsigned int) imm_opcode;
        ins->opcode = D.34378;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        D.34371 = D.32379->data.op[0].const_val;
        D.34379 = (void *) D.34371;
        ins->data.op[1].p = D.34379;
        ins->sreg2 = -1;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        D.32379->opcode = 316;
        <D.34377>:
      }
      <D.34374>:
      <D.34370>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.34380>; else goto <D.34381>;
      <D.34380>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.34382>;
      <D.34381>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.34382>:
      sp.130 = sp;
      sp = sp.130 + 8;
      D.34384 = mono_decompose_opcode (cfg, ins);
      *sp.130 = D.34384;
      ip = ip + 1;
      goto <D.27394>;
      <D.27638>:
      <D.27639>:
      <D.27640>:
      <D.27641>:
      <D.27642>:
      <D.27643>:
      <D.27644>:
      <D.27645>:
      <D.27646>:
      <D.27647>:
      <D.27648>:
      <D.27649>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 15) goto <D.34385>; else goto <D.34386>;
      <D.34385>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34387>; else goto <D.34388>;
      <D.34387>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34389>; else goto <D.34390>;
      <D.34389>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34390>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34388>:
      D.34391 = mini_get_debug_options ();
      D.34392 = D.34391->break_on_unverified;
      if (D.34392 != 0) goto <D.34393>; else goto unverified;
      <D.34393>:
      raise (5);
      <D.34386>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      D.31121 = *ip;
      D.33677 = (short unsigned int) D.31121;
      ins->opcode = D.33677;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      sp = sp + 18446744073709551600;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      D.32380 = D.32379->dreg;
      ins->sreg2 = D.32380;
      D.31240 = *sp;
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      type_from_op (ins, D.31240, D.32379);
      D.30988 = ins->type;
      if (D.30988 == 0) goto <D.34394>; else goto <D.34395>;
      <D.34394>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34396>; else goto <D.34397>;
      <D.34396>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34398>; else goto <D.34399>;
      <D.34398>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34399>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34397>:
      D.34400 = mini_get_debug_options ();
      D.34401 = D.34400->break_on_unverified;
      if (D.34401 != 0) goto <D.34402>; else goto unverified;
      <D.34402>:
      raise (5);
      <D.34395>:
      D.31240 = *sp;
      D.32922 = D.31240->type;
      if (D.32922 == 3) goto <D.34403>; else goto <D.34404>;
      <D.34403>:
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      D.34405 = D.32379->type;
      if (D.34405 == 1) goto <D.34406>; else goto <D.34407>;
      <D.34406>:
      {
        struct MonoInst * widen;
        int dr;

        D.34408 = alloc_preg (cfg);
        dr = (int) D.34408;
        D.30241 = cfg->mempool;
        widen = mono_mempool_alloc (D.30241, 80);
        widen->data.op[1].const_val = 0;
        D.34409 = widen->data.op[1].const_val;
        widen->data.op[0].const_val = D.34409;
        widen->prev = 0B;
        D.34410 = widen->prev;
        widen->next = D.34410;
        widen->opcode = 762;
        widen->flags = 0;
        widen->type = 0;
        widen->dreg = -1;
        widen->sreg3 = -1;
        D.34411 = widen->sreg3;
        widen->sreg2 = D.34411;
        D.34412 = widen->sreg2;
        widen->sreg1 = D.34412;
        D.30461 = cfg->ip;
        widen->cil_code = D.30461;
        widen->dreg = dr;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        D.32380 = D.32379->dreg;
        widen->sreg1 = D.32380;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.34413>; else goto <D.34414>;
        <D.34413>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = widen;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        widen->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = widen;
        goto <D.34415>;
        <D.34414>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = widen;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.34415>:
        D.34416 = widen->dreg;
        ins->sreg2 = D.34416;
      }
      <D.34407>:
      <D.34404>:
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.34417 = alloc_dreg (cfg, D.30989);
      D.34418 = (int) D.34417;
      ins->dreg = D.34418;
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      D.34346 = D.32379->opcode;
      D.34419 = D.34346 + 65174;
      if (D.34419 <= 1) goto <D.34420>; else goto <D.34421>;
      <D.34420>:
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      D.34346 = D.32379->opcode;
      if (D.34346 == 362) goto <D.34423>; else goto <D.34424>;
      <D.34423>:
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      iftmp.131 = D.32379->data.op[0].const_val;
      goto <D.34425>;
      <D.34424>:
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      iftmp.131 = D.32379->data.i8const;
      <D.34425>:
      D.34426 = mono_arch_is_inst_imm (iftmp.131);
      if (D.34426 != 0) goto <D.34427>; else goto <D.34428>;
      <D.34427>:
      {
        int imm_opcode;

        D.30992 = ins->opcode;
        D.34375 = (int) D.30992;
        imm_opcode = mono_op_to_op_imm_noemul (D.34375);
        if (imm_opcode != -1) goto <D.34429>; else goto <D.34430>;
        <D.34429>:
        D.34431 = (short unsigned int) imm_opcode;
        ins->opcode = D.34431;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        D.34346 = D.32379->opcode;
        if (D.34346 == 363) goto <D.34432>; else goto <D.34433>;
        <D.34432>:
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        D.34434 = D.32379->data.i8const;
        ins->data.op[1].const_val = D.34434;
        goto <D.34435>;
        <D.34433>:
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        D.34371 = D.32379->data.op[0].const_val;
        ins->data.op[1].const_val = D.34371;
        <D.34435>:
        ins->sreg2 = -1;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        D.34436 = D.32379->next;
        if (D.34436 == 0B) goto <D.34437>; else goto <D.34438>;
        <D.34437>:
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        D.32379->opcode = 316;
        <D.34438>:
        <D.34430>:
      }
      <D.34428>:
      <D.34421>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.34439>; else goto <D.34440>;
      <D.34439>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.34441>;
      <D.34440>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.34441>:
      sp.132 = sp;
      sp = sp.132 + 8;
      D.34443 = mono_decompose_opcode (cfg, ins);
      *sp.132 = D.34443;
      ip = ip + 1;
      goto <D.27394>;
      <D.27653>:
      <D.27654>:
      <D.27655>:
      <D.27656>:
      <D.27657>:
      <D.27658>:
      <D.27659>:
      <D.27660>:
      <D.27661>:
      <D.27662>:
      <D.27663>:
      <D.27664>:
      <D.27665>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.34444>; else goto <D.34445>;
      <D.34444>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34446>; else goto <D.34447>;
      <D.34446>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34448>; else goto <D.34449>;
      <D.34448>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34449>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34447>:
      D.34450 = mini_get_debug_options ();
      D.34451 = D.34450->break_on_unverified;
      if (D.34451 != 0) goto <D.34452>; else goto unverified;
      <D.34452>:
      raise (5);
      <D.34445>:
      D.31121 = *ip;
      if (D.31121 == 106) goto <D.34453>; else goto <D.34456>;
      <D.34456>:
      D.31121 = *ip;
      if (D.31121 == 110) goto <D.34453>; else goto <D.34454>;
      <D.34453>:
      D.33828 = sp + 18446744073709551608;
      D.33829 = *D.33828;
      D.34457 = D.33829->opcode;
      if (D.34457 == 362) goto <D.34458>; else goto <D.34454>;
      <D.34458>:
      {
        int data;

        D.33828 = sp + 18446744073709551608;
        D.33829 = *D.33828;
        D.34459 = D.33829->data.op[0].const_val;
        data = (int) D.34459;
        D.33828 = sp + 18446744073709551608;
        D.33829 = *D.33828;
        D.33829->opcode = 363;
        D.33828 = sp + 18446744073709551608;
        D.33829 = *D.33828;
        D.33829->type = 2;
        D.31121 = *ip;
        if (D.31121 == 110) goto <D.34460>; else goto <D.34461>;
        <D.34460>:
        D.33828 = sp + 18446744073709551608;
        D.33829 = *D.33828;
        data.133 = (unsigned int) data;
        D.34463 = (long int) data.133;
        D.33829->data.op[0].const_val = D.34463;
        goto <D.34464>;
        <D.34461>:
        D.33828 = sp + 18446744073709551608;
        D.33829 = *D.33828;
        D.34465 = (long int) data;
        D.33829->data.op[0].const_val = D.34465;
        <D.34464>:
        D.33828 = sp + 18446744073709551608;
        D.33829 = *D.33828;
        D.34466 = alloc_dreg (cfg, 2);
        D.34467 = (int) D.34466;
        D.33829->dreg = D.34467;
      }
      goto <D.34455>;
      <D.34454>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      D.31121 = *ip;
      D.33677 = (short unsigned int) D.31121;
      ins->opcode = D.33677;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      sp = sp + 18446744073709551608;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      D.31240 = *sp;
      type_from_op (ins, D.31240, 0B);
      D.30988 = ins->type;
      if (D.30988 == 0) goto <D.34468>; else goto <D.34469>;
      <D.34468>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34470>; else goto <D.34471>;
      <D.34470>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34472>; else goto <D.34473>;
      <D.34472>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34473>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34471>:
      D.34474 = mini_get_debug_options ();
      D.34475 = D.34474->break_on_unverified;
      if (D.34475 != 0) goto <D.34476>; else goto unverified;
      <D.34476>:
      raise (5);
      <D.34469>:
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.34477 = alloc_dreg (cfg, D.30989);
      D.34478 = (int) D.34477;
      ins->dreg = D.34478;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.34479>; else goto <D.34480>;
      <D.34479>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.34481>;
      <D.34480>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.34481>:
      sp.134 = sp;
      sp = sp.134 + 8;
      D.34483 = mono_decompose_opcode (cfg, ins);
      *sp.134 = D.34483;
      <D.34455>:
      ip = ip + 1;
      goto <D.27394>;
      <D.27667>:
      <D.27668>:
      <D.27669>:
      <D.27670>:
      <D.27671>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.34484>; else goto <D.34485>;
      <D.34484>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34486>; else goto <D.34487>;
      <D.34486>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34488>; else goto <D.34489>;
      <D.34488>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34489>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34487>:
      D.34490 = mini_get_debug_options ();
      D.34491 = D.34490->break_on_unverified;
      if (D.34491 != 0) goto <D.34492>; else goto unverified;
      <D.34492>:
      raise (5);
      <D.34485>:
      D.33828 = sp + 18446744073709551608;
      D.33829 = *D.33828;
      D.33830 = D.33829->type;
      if (D.33830 == 4) goto <D.34493>; else goto <D.34494>;
      <D.34493>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 185;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      sp = sp + 18446744073709551608;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      D.31240 = *sp;
      type_from_op (ins, D.31240, 0B);
      D.30988 = ins->type;
      if (D.30988 == 0) goto <D.34495>; else goto <D.34496>;
      <D.34495>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34497>; else goto <D.34498>;
      <D.34497>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34499>; else goto <D.34500>;
      <D.34499>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34500>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34498>:
      D.34501 = mini_get_debug_options ();
      D.34502 = D.34501->break_on_unverified;
      if (D.34502 != 0) goto <D.34503>; else goto unverified;
      <D.34503>:
      raise (5);
      <D.34496>:
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.34504 = alloc_dreg (cfg, D.30989);
      D.34505 = (int) D.34504;
      ins->dreg = D.34505;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.34506>; else goto <D.34507>;
      <D.34506>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.34508>;
      <D.34507>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.34508>:
      sp.135 = sp;
      sp = sp.135 + 8;
      D.34510 = mono_decompose_opcode (cfg, ins);
      *sp.135 = D.34510;
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      D.31121 = *ip;
      D.33677 = (short unsigned int) D.31121;
      ins->opcode = D.33677;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      sp = sp + 18446744073709551608;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      D.31240 = *sp;
      type_from_op (ins, D.31240, 0B);
      D.30988 = ins->type;
      if (D.30988 == 0) goto <D.34511>; else goto <D.34512>;
      <D.34511>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34513>; else goto <D.34514>;
      <D.34513>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34515>; else goto <D.34516>;
      <D.34515>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34516>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34514>:
      D.34517 = mini_get_debug_options ();
      D.34518 = D.34517->break_on_unverified;
      if (D.34518 != 0) goto <D.34519>; else goto unverified;
      <D.34519>:
      raise (5);
      <D.34512>:
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.34520 = alloc_dreg (cfg, D.30989);
      D.34521 = (int) D.34520;
      ins->dreg = D.34521;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.34522>; else goto <D.34523>;
      <D.34522>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.34524>;
      <D.34523>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.34524>:
      sp.136 = sp;
      sp = sp.136 + 8;
      D.34526 = mono_decompose_opcode (cfg, ins);
      *sp.136 = D.34526;
      goto <D.34527>;
      <D.34494>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      D.31121 = *ip;
      D.33677 = (short unsigned int) D.31121;
      ins->opcode = D.33677;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      sp = sp + 18446744073709551608;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      D.31240 = *sp;
      type_from_op (ins, D.31240, 0B);
      D.30988 = ins->type;
      if (D.30988 == 0) goto <D.34528>; else goto <D.34529>;
      <D.34528>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34530>; else goto <D.34531>;
      <D.34530>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34532>; else goto <D.34533>;
      <D.34532>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34533>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34531>:
      D.34534 = mini_get_debug_options ();
      D.34535 = D.34534->break_on_unverified;
      if (D.34535 != 0) goto <D.34536>; else goto unverified;
      <D.34536>:
      raise (5);
      <D.34529>:
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.34537 = alloc_dreg (cfg, D.30989);
      D.34538 = (int) D.34537;
      ins->dreg = D.34538;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.34539>; else goto <D.34540>;
      <D.34539>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.34541>;
      <D.34540>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.34541>:
      sp.137 = sp;
      sp = sp.137 + 8;
      D.34543 = mono_decompose_opcode (cfg, ins);
      *sp.137 = D.34543;
      <D.34527>:
      ip = ip + 1;
      goto <D.27394>;
      <D.27672>:
      <D.27673>:
      <D.27674>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.34544>; else goto <D.34545>;
      <D.34544>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34546>; else goto <D.34547>;
      <D.34546>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34548>; else goto <D.34549>;
      <D.34548>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34549>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34547>:
      D.34550 = mini_get_debug_options ();
      D.34551 = D.34550->break_on_unverified;
      if (D.34551 != 0) goto <D.34552>; else goto unverified;
      <D.34552>:
      raise (5);
      <D.34545>:
      D.33828 = sp + 18446744073709551608;
      D.33829 = *D.33828;
      D.33830 = D.33829->type;
      if (D.33830 == 4) goto <D.34553>; else goto <D.34554>;
      <D.34553>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 186;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      sp = sp + 18446744073709551608;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      D.31240 = *sp;
      type_from_op (ins, D.31240, 0B);
      D.30988 = ins->type;
      if (D.30988 == 0) goto <D.34555>; else goto <D.34556>;
      <D.34555>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34557>; else goto <D.34558>;
      <D.34557>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34559>; else goto <D.34560>;
      <D.34559>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34560>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34558>:
      D.34561 = mini_get_debug_options ();
      D.34562 = D.34561->break_on_unverified;
      if (D.34562 != 0) goto <D.34563>; else goto unverified;
      <D.34563>:
      raise (5);
      <D.34556>:
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.34564 = alloc_dreg (cfg, D.30989);
      D.34565 = (int) D.34564;
      ins->dreg = D.34565;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.34566>; else goto <D.34567>;
      <D.34566>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.34568>;
      <D.34567>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.34568>:
      sp.138 = sp;
      sp = sp.138 + 8;
      D.34570 = mono_decompose_opcode (cfg, ins);
      *sp.138 = D.34570;
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      D.31121 = *ip;
      D.33677 = (short unsigned int) D.31121;
      ins->opcode = D.33677;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      sp = sp + 18446744073709551608;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      D.31240 = *sp;
      type_from_op (ins, D.31240, 0B);
      D.30988 = ins->type;
      if (D.30988 == 0) goto <D.34571>; else goto <D.34572>;
      <D.34571>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34573>; else goto <D.34574>;
      <D.34573>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34575>; else goto <D.34576>;
      <D.34575>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34576>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34574>:
      D.34577 = mini_get_debug_options ();
      D.34578 = D.34577->break_on_unverified;
      if (D.34578 != 0) goto <D.34579>; else goto unverified;
      <D.34579>:
      raise (5);
      <D.34572>:
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.34580 = alloc_dreg (cfg, D.30989);
      D.34581 = (int) D.34580;
      ins->dreg = D.34581;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.34582>; else goto <D.34583>;
      <D.34582>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.34584>;
      <D.34583>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.34584>:
      sp.139 = sp;
      sp = sp.139 + 8;
      D.34586 = mono_decompose_opcode (cfg, ins);
      *sp.139 = D.34586;
      goto <D.34587>;
      <D.34554>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      D.31121 = *ip;
      D.33677 = (short unsigned int) D.31121;
      ins->opcode = D.33677;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      sp = sp + 18446744073709551608;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      D.31240 = *sp;
      type_from_op (ins, D.31240, 0B);
      D.30988 = ins->type;
      if (D.30988 == 0) goto <D.34588>; else goto <D.34589>;
      <D.34588>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34590>; else goto <D.34591>;
      <D.34590>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34592>; else goto <D.34593>;
      <D.34592>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34593>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34591>:
      D.34594 = mini_get_debug_options ();
      D.34595 = D.34594->break_on_unverified;
      if (D.34595 != 0) goto <D.34596>; else goto unverified;
      <D.34596>:
      raise (5);
      <D.34589>:
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.34597 = alloc_dreg (cfg, D.30989);
      D.34598 = (int) D.34597;
      ins->dreg = D.34598;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.34599>; else goto <D.34600>;
      <D.34599>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.34601>;
      <D.34600>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.34601>:
      sp.140 = sp;
      sp = sp.140 + 8;
      D.34603 = mono_decompose_opcode (cfg, ins);
      *sp.140 = D.34603;
      <D.34587>:
      ip = ip + 1;
      goto <D.27394>;
      <D.27675>:
      <D.27676>:
      <D.27677>:
      <D.27678>:
      <D.27679>:
      <D.27680>:
      <D.27681>:
      <D.27682>:
      <D.27683>:
      <D.27684>:
      <D.27685>:
      <D.27686>:
      <D.27687>:
      <D.27688>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.34604>; else goto <D.34605>;
      <D.34604>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34606>; else goto <D.34607>;
      <D.34606>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34608>; else goto <D.34609>;
      <D.34608>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34609>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34607>:
      D.34610 = mini_get_debug_options ();
      D.34611 = D.34610->break_on_unverified;
      if (D.34611 != 0) goto <D.34612>; else goto unverified;
      <D.34612>:
      raise (5);
      <D.34605>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      D.31121 = *ip;
      D.33677 = (short unsigned int) D.31121;
      ins->opcode = D.33677;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      sp = sp + 18446744073709551608;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      D.31240 = *sp;
      type_from_op (ins, D.31240, 0B);
      D.30988 = ins->type;
      if (D.30988 == 0) goto <D.34613>; else goto <D.34614>;
      <D.34613>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34615>; else goto <D.34616>;
      <D.34615>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34617>; else goto <D.34618>;
      <D.34617>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34618>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34616>:
      D.34619 = mini_get_debug_options ();
      D.34620 = D.34619->break_on_unverified;
      if (D.34620 != 0) goto <D.34621>; else goto unverified;
      <D.34621>:
      raise (5);
      <D.34614>:
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.34622 = alloc_dreg (cfg, D.30989);
      D.34623 = (int) D.34622;
      ins->dreg = D.34623;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.34624>; else goto <D.34625>;
      <D.34624>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.34626>;
      <D.34625>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.34626>:
      sp.141 = sp;
      sp = sp.141 + 8;
      D.34628 = mono_decompose_opcode (cfg, ins);
      *sp.141 = D.34628;
      D.30793 = cfg->exception_type;
      if (D.30793 != 0) goto exception_exit; else goto <D.34629>;
      <D.34629>:
      ip = ip + 1;
      goto <D.27394>;
      <D.27689>:
      <D.27690>:
      <D.27691>:
      <D.27692>:
      <D.27693>:
      <D.27694>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 15) goto <D.34630>; else goto <D.34631>;
      <D.34630>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34632>; else goto <D.34633>;
      <D.34632>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34634>; else goto <D.34635>;
      <D.34634>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34635>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34633>:
      D.34636 = mini_get_debug_options ();
      D.34637 = D.34636->break_on_unverified;
      if (D.34637 != 0) goto <D.34638>; else goto unverified;
      <D.34638>:
      raise (5);
      <D.34631>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      D.31121 = *ip;
      D.33677 = (short unsigned int) D.31121;
      ins->opcode = D.33677;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      sp = sp + 18446744073709551600;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      D.32380 = D.32379->dreg;
      ins->sreg2 = D.32380;
      D.31240 = *sp;
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      type_from_op (ins, D.31240, D.32379);
      D.30988 = ins->type;
      if (D.30988 == 0) goto <D.34639>; else goto <D.34640>;
      <D.34639>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34641>; else goto <D.34642>;
      <D.34641>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34643>; else goto <D.34644>;
      <D.34643>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34644>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34642>:
      D.34645 = mini_get_debug_options ();
      D.34646 = D.34645->break_on_unverified;
      if (D.34646 != 0) goto <D.34647>; else goto unverified;
      <D.34647>:
      raise (5);
      <D.34640>:
      D.31240 = *sp;
      D.32922 = D.31240->type;
      if (D.32922 == 3) goto <D.34648>; else goto <D.34649>;
      <D.34648>:
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      D.34405 = D.32379->type;
      if (D.34405 == 1) goto <D.34650>; else goto <D.34651>;
      <D.34650>:
      {
        struct MonoInst * widen;
        int dr;

        D.34652 = alloc_preg (cfg);
        dr = (int) D.34652;
        D.30241 = cfg->mempool;
        widen = mono_mempool_alloc (D.30241, 80);
        widen->data.op[1].const_val = 0;
        D.34653 = widen->data.op[1].const_val;
        widen->data.op[0].const_val = D.34653;
        widen->prev = 0B;
        D.34654 = widen->prev;
        widen->next = D.34654;
        widen->opcode = 762;
        widen->flags = 0;
        widen->type = 0;
        widen->dreg = -1;
        widen->sreg3 = -1;
        D.34655 = widen->sreg3;
        widen->sreg2 = D.34655;
        D.34656 = widen->sreg2;
        widen->sreg1 = D.34656;
        D.30461 = cfg->ip;
        widen->cil_code = D.30461;
        widen->dreg = dr;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        D.32380 = D.32379->dreg;
        widen->sreg1 = D.32380;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.34657>; else goto <D.34658>;
        <D.34657>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = widen;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        widen->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = widen;
        goto <D.34659>;
        <D.34658>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = widen;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.34659>:
        D.34660 = widen->dreg;
        ins->sreg2 = D.34660;
      }
      <D.34651>:
      <D.34649>:
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.34661 = alloc_dreg (cfg, D.30989);
      D.34662 = (int) D.34661;
      ins->dreg = D.34662;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.34663>; else goto <D.34664>;
      <D.34663>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.34665>;
      <D.34664>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.34665>:
      sp.142 = sp;
      sp = sp.142 + 8;
      D.34667 = mono_decompose_opcode (cfg, ins);
      *sp.142 = D.34667;
      ip = ip + 1;
      goto <D.27394>;
      <D.27697>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34668>; else goto <D.34669>;
      <D.34668>:
      D.30178 = method->klass;
      D.31934 = D.30178->name_space;
      D.30178 = method->klass;
      D.31935 = D.30178->name;
      D.31936 = method->name;
      D.31937 = method->signature;
      D.31938 = D.31937->param_count;
      D.31939 = (int) D.31938;
      D.31121 = *ip;
      D.31122 = (int) D.31121;
      D.34670 = mono_opcode_name (D.31122);
      D.34671 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.31934, D.31935, D.31936, D.31939, D.34670, "method-to-ir.c", 9069);
      cfg->exception_message = D.34671;
      D.30322 = cfg->verbose_level;
      if (D.30322 > 1) goto <D.34672>; else goto <D.34673>;
      <D.34672>:
      D.31944 = cfg->exception_message;
      printf ("%s\n", D.31944);
      <D.34673>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34669>:
      D.31664 = ip + 5;
      if (D.31664 > end) goto <D.34674>; else goto <D.34675>;
      <D.34674>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34676>; else goto <D.34677>;
      <D.34676>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34678>; else goto <D.34679>;
      <D.34678>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34679>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34677>:
      D.34680 = mini_get_debug_options ();
      D.34681 = D.34680->break_on_unverified;
      if (D.34681 != 0) goto <D.34682>; else goto unverified;
      <D.34682>:
      raise (5);
      <D.34675>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 15) goto <D.34683>; else goto <D.34684>;
      <D.34683>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34685>; else goto <D.34686>;
      <D.34685>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34687>; else goto <D.34688>;
      <D.34687>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34688>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34686>:
      D.34689 = mini_get_debug_options ();
      D.34690 = D.34689->break_on_unverified;
      if (D.34690 != 0) goto <D.34691>; else goto unverified;
      <D.34691>:
      raise (5);
      <D.34684>:
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31684 = D.31683 << 24;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31685 = D.31683 >> 8;
      D.31686 = D.31685 & 65280;
      D.31687 = D.31684 | D.31686;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31688 = D.31683 << 8;
      D.31689 = D.31688 & 16711680;
      D.31690 = D.31687 | D.31689;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31691 = D.31683 >> 24;
      token = D.31690 | D.31691;
      klass.143 = mini_get_class (method, token, generic_context);
      klass = klass.143;
      klass.144 = klass;
      if (klass.144 == 0B) goto <D.34693>; else goto <D.34696>;
      <D.34696>:
      klass.144 = klass;
      D.34697 = klass.144->exception_type;
      if (D.34697 != 0) goto <D.34693>; else goto <D.34694>;
      <D.34693>:
      klass.144 = klass;
      cfg->exception_ptr = klass.144;
      D.34698 = mini_get_debug_options ();
      D.34699 = D.34698->break_on_unverified;
      if (D.34699 != 0) goto <D.34700>; else goto load_error;
      <D.34700>:
      raise (5);
      <D.34694>:
      sp = sp + 18446744073709551600;
      klass.144 = klass;
      D.34701 = generic_class_is_reference_type (cfg, klass.144);
      if (D.34701 != 0) goto <D.34702>; else goto <D.34703>;
      <D.34702>:
      {
        struct MonoInst * store;
        struct MonoInst * load;
        int dreg;

        D.34704 = alloc_ireg_ref (cfg);
        dreg = (int) D.34704;
        D.30241 = cfg->mempool;
        load = mono_mempool_alloc (D.30241, 80);
        load->data.op[1].const_val = 0;
        D.34705 = load->data.op[1].const_val;
        load->data.op[0].const_val = D.34705;
        load->prev = 0B;
        D.34706 = load->prev;
        load->next = D.34706;
        load->opcode = 388;
        load->flags = 0;
        load->type = 0;
        load->dreg = -1;
        load->sreg3 = -1;
        D.34707 = load->sreg3;
        load->sreg2 = D.34707;
        D.34708 = load->sreg2;
        load->sreg1 = D.34708;
        D.30461 = cfg->ip;
        load->cil_code = D.30461;
        load->dreg = dreg;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        D.32380 = D.32379->dreg;
        load->sreg1 = D.32380;
        load->data.op[0].const_val = 0;
        load->type = 1;
        D.34709 = load->flags;
        D.34312 = (unsigned char) ins_flag;
        D.34710 = D.34709 | D.34312;
        load->flags = D.34710;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.34711>; else goto <D.34712>;
        <D.34711>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = load;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        load->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = load;
        goto <D.34713>;
        <D.34712>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = load;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.34713>:
        D.30241 = cfg->mempool;
        store = mono_mempool_alloc (D.30241, 80);
        store->data.op[1].const_val = 0;
        D.34714 = store->data.op[1].const_val;
        store->data.op[0].const_val = D.34714;
        store->prev = 0B;
        D.34715 = store->prev;
        store->next = D.34715;
        store->opcode = 374;
        store->flags = 0;
        store->type = 0;
        store->dreg = -1;
        store->sreg3 = -1;
        D.34716 = store->sreg3;
        store->sreg2 = D.34716;
        D.34717 = store->sreg2;
        store->sreg1 = D.34717;
        D.30461 = cfg->ip;
        store->cil_code = D.30461;
        store->sreg1 = dreg;
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        store->dreg = D.31422;
        store->data.op[0].const_val = 0;
        D.34718 = store->flags;
        D.34312 = (unsigned char) ins_flag;
        D.34719 = D.34718 | D.34312;
        store->flags = D.34719;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.34720>; else goto <D.34721>;
        <D.34720>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = store;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        store->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = store;
        goto <D.34722>;
        <D.34721>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = store;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.34722>:
        D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.33278 = D.30634 & 8;
        if (D.33278 != 0) goto <D.34723>; else goto <D.34724>;
        <D.34723>:
        D.30211 = cfg->method;
        D.32174 = BIT_FIELD_REF <*D.30211, 64, 256>;
        D.32175 = D.32174 & 4467570830351532032;
        if (D.32175 != 3458764513820540928) goto <D.34725>; else goto <D.34726>;
        <D.34725>:
        D.31240 = *sp;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        emit_write_barrier (cfg, D.31240, D.32379);
        <D.34726>:
        <D.34724>:
      }
      goto <D.34727>;
      <D.34703>:
      D.31240 = *sp;
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      klass.144 = klass;
      mini_emit_stobj (cfg, D.31240, D.32379, klass.144, 0);
      <D.34727>:
      ins_flag = 0;
      ip = ip + 5;
      goto <D.27394>;
      <D.27701>:
      {
        int loc_index;
        int stloc_len;

        loc_index = -1;
        stloc_len = 0;
        D.31664 = ip + 5;
        if (D.31664 > end) goto <D.34728>; else goto <D.34729>;
        <D.34728>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.34730>; else goto <D.34731>;
        <D.34730>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.34732>; else goto <D.34733>;
        <D.34732>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34733>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34731>:
        D.34734 = mini_get_debug_options ();
        D.34735 = D.34734->break_on_unverified;
        if (D.34735 != 0) goto <D.34736>; else goto unverified;
        <D.34736>:
        raise (5);
        <D.34729>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        if (D.31013 <= 7) goto <D.34737>; else goto <D.34738>;
        <D.34737>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.34739>; else goto <D.34740>;
        <D.34739>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.34741>; else goto <D.34742>;
        <D.34741>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34742>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34740>:
        D.34743 = mini_get_debug_options ();
        D.34744 = D.34743->break_on_unverified;
        if (D.34744 != 0) goto <D.34745>; else goto unverified;
        <D.34745>:
        raise (5);
        <D.34738>:
        sp = sp + 18446744073709551608;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31684 = D.31683 << 24;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31685 = D.31683 >> 8;
        D.31686 = D.31685 & 65280;
        D.31687 = D.31684 | D.31686;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31688 = D.31683 << 8;
        D.31689 = D.31688 & 16711680;
        D.31690 = D.31687 | D.31689;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31691 = D.31683 >> 24;
        token = D.31690 | D.31691;
        klass.145 = mini_get_class (method, token, generic_context);
        klass = klass.145;
        klass.144 = klass;
        if (klass.144 == 0B) goto <D.34747>; else goto <D.34749>;
        <D.34749>:
        klass.144 = klass;
        D.34697 = klass.144->exception_type;
        if (D.34697 != 0) goto <D.34747>; else goto <D.34748>;
        <D.34747>:
        klass.144 = klass;
        cfg->exception_ptr = klass.144;
        D.34750 = mini_get_debug_options ();
        D.34751 = D.34750->break_on_unverified;
        if (D.34751 != 0) goto <D.34752>; else goto load_error;
        <D.34752>:
        raise (5);
        <D.34748>:
        D.31664 = ip + 5;
        D.32220 = *D.31664;
        D.34753 = (int) D.32220;
        switch (D.34753) <default: <D.27710>, case 10: <D.27706>, case 11: <D.27707>, case 12: <D.27708>, case 13: <D.27709>, case 19: <D.27704>>
        <D.27704>:
        D.34754 = ip + 6;
        D.34755 = *D.34754;
        loc_index = (int) D.34755;
        stloc_len = 2;
        goto <D.27705>;
        <D.27706>:
        <D.27707>:
        <D.27708>:
        <D.27709>:
        D.31664 = ip + 5;
        D.32220 = *D.31664;
        D.34753 = (int) D.32220;
        loc_index = D.34753 + -10;
        stloc_len = 1;
        goto <D.27705>;
        <D.27710>:
        goto <D.27705>;
        <D.27705>:
        if (loc_index != -1) goto <D.34756>; else goto <D.34757>;
        <D.34756>:
        bblock.64 = bblock;
        D.31664 = ip + 5;
        D.34758 = ip_in_bb (cfg, bblock.64, D.31664);
        if (D.34758 != 0) goto <D.34759>; else goto <D.34760>;
        <D.34759>:
        D.30829 = header->num_locals;
        D.31194 = (unsigned int) D.30829;
        loc_index.146 = (unsigned int) loc_index;
        if (D.31194 <= loc_index.146) goto <D.34762>; else goto <D.34763>;
        <D.34762>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.34764>; else goto <D.34765>;
        <D.34764>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.34766>; else goto <D.34767>;
        <D.34766>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34767>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34765>:
        D.34768 = mini_get_debug_options ();
        D.34769 = D.34768->break_on_unverified;
        if (D.34769 != 0) goto <D.34770>; else goto unverified;
        <D.34770>:
        raise (5);
        <D.34763>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        klass.144 = klass;
        D.34771 = &klass.144->byval_arg;
        D.34772 = mono_type_to_load_membase (cfg, D.34771);
        D.34773 = (short unsigned int) D.34772;
        ins->opcode = D.34773;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        ins->dreg = 0;
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        ins->sreg1 = D.31422;
        ins->data.op[0].const_val = 0;
        ins->type = 1;
        klass.144 = klass;
        D.34771 = &klass.144->byval_arg;
        type_to_eval_stack_type (cfg, D.34771, ins);
        D.30988 = ins->type;
        D.30989 = (<unnamed type>) D.30988;
        D.34774 = alloc_dreg (cfg, D.30989);
        D.34775 = (int) D.34774;
        ins->dreg = D.34775;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.34776>; else goto <D.34777>;
        <D.34776>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.34778>;
        <D.34777>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.34778>:
        D.31206 = cfg->locals;
        D.34779 = (long unsigned int) loc_index;
        D.34780 = D.34779 * 8;
        D.34781 = D.31206 + D.34780;
        D.34782 = *D.34781;
        D.34783 = D.34782->dreg;
        ins->dreg = D.34783;
        ip = ip + 5;
        D.34784 = (sizetype) stloc_len;
        ip = ip + D.34784;
        goto <D.27394>;
        <D.34760>:
        <D.34757>:
        D.31664 = ip + 5;
        D.32220 = *D.31664;
        if (D.32220 == 129) goto <D.34785>; else goto <D.34786>;
        <D.34785>:
        bblock.64 = bblock;
        D.31664 = ip + 5;
        D.34787 = ip_in_bb (cfg, bblock.64, D.31664);
        if (D.34787 != 0) goto <D.34788>; else goto <D.34789>;
        <D.34788>:
        D.34754 = ip + 6;
        D.34790 = MEM[(const guint32 *)D.34754];
        D.34791 = D.34790 << 24;
        D.34754 = ip + 6;
        D.34790 = MEM[(const guint32 *)D.34754];
        D.34792 = D.34790 >> 8;
        D.34793 = D.34792 & 65280;
        D.34794 = D.34791 | D.34793;
        D.34754 = ip + 6;
        D.34790 = MEM[(const guint32 *)D.34754];
        D.34795 = D.34790 << 8;
        D.34796 = D.34795 & 16711680;
        D.34797 = D.34794 | D.34796;
        D.34754 = ip + 6;
        D.34790 = MEM[(const guint32 *)D.34754];
        D.34798 = D.34790 >> 24;
        D.34799 = D.34797 | D.34798;
        if (D.34799 == token) goto <D.34800>; else goto <D.34801>;
        <D.34800>:
        klass.144 = klass;
        D.34802 = generic_class_is_reference_type (cfg, klass.144);
        if (D.34802 == 0) goto <D.34803>; else goto <D.34804>;
        <D.34803>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        if (D.31013 <= 7) goto <D.34805>; else goto <D.34806>;
        <D.34805>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.34807>; else goto <D.34808>;
        <D.34807>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.34809>; else goto <D.34810>;
        <D.34809>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.34810>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.34808>:
        D.34811 = mini_get_debug_options ();
        D.34812 = D.34811->break_on_unverified;
        if (D.34812 != 0) goto <D.34813>; else goto unverified;
        <D.34813>:
        raise (5);
        <D.34806>:
        sp = sp + 18446744073709551608;
        D.31240 = *sp;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        klass.144 = klass;
        mini_emit_stobj (cfg, D.31240, D.32379, klass.144, 0);
        ip = ip + 10;
        ins_flag = 0;
        goto <D.27394>;
        <D.34804>:
        <D.34801>:
        <D.34789>:
        <D.34786>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        klass.144 = klass;
        D.34771 = &klass.144->byval_arg;
        D.34814 = mono_type_to_load_membase (cfg, D.34771);
        D.34815 = (short unsigned int) D.34814;
        ins->opcode = D.34815;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        ins->dreg = 0;
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        ins->sreg1 = D.31422;
        ins->data.op[0].const_val = 0;
        ins->type = 1;
        klass.144 = klass;
        D.34771 = &klass.144->byval_arg;
        type_to_eval_stack_type (cfg, D.34771, ins);
        D.30988 = ins->type;
        D.30989 = (<unnamed type>) D.30988;
        D.34816 = alloc_dreg (cfg, D.30989);
        D.34817 = (int) D.34816;
        ins->dreg = D.34817;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.34818>; else goto <D.34819>;
        <D.34818>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.34820>;
        <D.34819>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.34820>:
        sp.147 = sp;
        sp = sp.147 + 8;
        *sp.147 = ins;
        ip = ip + 5;
        ins_flag = 0;
        inline_costs = inline_costs + 1;
        goto <D.27394>;
      }
      <D.27711>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.30924 = header->max_stack;
      D.31146 = (long int) D.30924;
      if (D.31014 >= D.31146) goto <D.34822>; else goto <D.34823>;
      <D.34822>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34824>; else goto <D.34825>;
      <D.34824>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34826>; else goto <D.34827>;
      <D.34826>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34827>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34825>:
      D.34828 = mini_get_debug_options ();
      D.34829 = D.34828->break_on_unverified;
      if (D.34829 != 0) goto <D.34830>; else goto unverified;
      <D.34830>:
      raise (5);
      <D.34823>:
      D.31664 = ip + 5;
      if (D.31664 > end) goto <D.34831>; else goto <D.34832>;
      <D.34831>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.34833>; else goto <D.34834>;
      <D.34833>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.34835>; else goto <D.34836>;
      <D.34835>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.34836>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.34834>:
      D.34837 = mini_get_debug_options ();
      D.34838 = D.34837->break_on_unverified;
      if (D.34838 != 0) goto <D.34839>; else goto unverified;
      <D.34839>:
      raise (5);
      <D.34832>:
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31684 = D.31683 << 24;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31685 = D.31683 >> 8;
      D.31686 = D.31685 & 65280;
      D.31687 = D.31684 | D.31686;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31688 = D.31683 << 8;
      D.31689 = D.31688 & 16711680;
      D.31690 = D.31687 | D.31689;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31691 = D.31683 >> 24;
      D.31692 = D.31690 | D.31691;
      n = (int) D.31692;
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30184 = D.30183 & 4467570830351532032;
      if (D.30184 == 2449958197289549824) goto <D.34840>; else goto <D.34841>;
      <D.34840>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 363;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      n.148 = (unsigned int) n;
      D.34843 = mono_method_get_wrapper_data (method, n.148);
      ins->data.op[0].p = D.34843;
      ins->type = 3;
      D.34844 = alloc_dreg (cfg, 3);
      D.34845 = (int) D.34844;
      ins->dreg = D.34845;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.34846>; else goto <D.34847>;
      <D.34846>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.34848>;
      <D.34847>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.34848>:
      ins->type = 6;
      *sp = ins;
      goto <D.34849>;
      <D.34841>:
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30184 = D.30183 & 4467570830351532032;
      if (D.30184 != 0) goto <D.34850>; else goto <D.34851>;
      <D.34850>:
      {
        struct MonoInst * iargs[1];

        try
          {
            D.30241 = cfg->mempool;
            D.34852 = mono_mempool_alloc (D.30241, 80);
            iargs[0] = D.34852;
            D.34853 = iargs[0];
            D.34853 = iargs[0];
            D.34853->data.op[1].const_val = 0;
            D.34854 = D.34853->data.op[1].const_val;
            D.34853->data.op[0].const_val = D.34854;
            D.34853 = iargs[0];
            D.34853 = iargs[0];
            D.34853->prev = 0B;
            D.34855 = D.34853->prev;
            D.34853->next = D.34855;
            D.34853 = iargs[0];
            D.34853->opcode = 363;
            D.34853 = iargs[0];
            D.34853->flags = 0;
            D.34853 = iargs[0];
            D.34853->type = 0;
            D.34853 = iargs[0];
            D.34853->dreg = -1;
            D.34853 = iargs[0];
            D.34853 = iargs[0];
            D.34853 = iargs[0];
            D.34853->sreg3 = -1;
            D.34856 = D.34853->sreg3;
            D.34853->sreg2 = D.34856;
            D.34857 = D.34853->sreg2;
            D.34853->sreg1 = D.34857;
            D.34853 = iargs[0];
            D.30461 = cfg->ip;
            D.34853->cil_code = D.30461;
            D.34853 = iargs[0];
            n.148 = (unsigned int) n;
            D.34858 = mono_method_get_wrapper_data (method, n.148);
            D.34853->data.op[0].p = D.34858;
            D.34853 = iargs[0];
            D.34853->type = 3;
            D.34853 = iargs[0];
            D.34859 = alloc_dreg (cfg, 3);
            D.34860 = (int) D.34859;
            D.34853->dreg = D.34860;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.34861>; else goto <D.34862>;
            <D.34861>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34853 = iargs[0];
            D.30490->next = D.34853;
            D.34853 = iargs[0];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34853->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.34853 = iargs[0];
            bblock.106->last_ins = D.34853;
            goto <D.34863>;
            <D.34862>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.34853 = iargs[0];
            bblock.106->last_ins = D.34853;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.34863>:
            D.34864 = mono_emit_jit_icall (cfg, mono_string_new_wrapper, &iargs);
            *sp = D.34864;
          }
        finally
          {
            iargs = {CLOBBER};
          }
      }
      goto <D.34865>;
      <D.34851>:
      D.30632 = cfg->opt;
      D.30633 = D.30632 & 512;
      if (D.30633 != 0) goto <D.34866>; else goto <D.34867>;
      <D.34866>:
      {
        struct MonoInst * iargs[3];

        try
          {
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.34868>; else goto <D.34869>;
            <D.34868>:
            D.34870 = cfg->ldstr_list;
            D.32275 = (long int) n;
            D.34871 = (void *) D.32275;
            D.34872 = monoeg_g_list_prepend (D.34870, D.34871);
            cfg->ldstr_list = D.34872;
            <D.34869>:
            D.30632 = cfg->opt;
            D.30633 = D.30632 & 512;
            if (D.30633 != 0) goto <D.34873>; else goto <D.34876>;
            <D.34876>:
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.34873>; else goto <D.34874>;
            <D.34873>:
            {
              struct MonoInst * __domain_var;

              __domain_var = mono_get_domainvar (cfg);
              D.30241 = cfg->mempool;
              D.34877 = mono_mempool_alloc (D.30241, 80);
              iargs[0] = D.34877;
              D.34878 = iargs[0];
              D.34878 = iargs[0];
              D.34878->data.op[1].const_val = 0;
              D.34879 = D.34878->data.op[1].const_val;
              D.34878->data.op[0].const_val = D.34879;
              D.34878 = iargs[0];
              D.34878 = iargs[0];
              D.34878->prev = 0B;
              D.34880 = D.34878->prev;
              D.34878->next = D.34880;
              D.34878 = iargs[0];
              D.34878->opcode = 424;
              D.34878 = iargs[0];
              D.34878->flags = 0;
              D.34878 = iargs[0];
              D.34878->type = 0;
              D.34878 = iargs[0];
              D.34878->dreg = -1;
              D.34878 = iargs[0];
              D.34878 = iargs[0];
              D.34878 = iargs[0];
              D.34878->sreg3 = -1;
              D.34881 = D.34878->sreg3;
              D.34878->sreg2 = D.34881;
              D.34882 = D.34878->sreg2;
              D.34878->sreg1 = D.34882;
              D.34878 = iargs[0];
              D.30461 = cfg->ip;
              D.34878->cil_code = D.30461;
              D.34878 = iargs[0];
              D.30978 = cfg->varinfo;
              D.34883 = __domain_var->data.op[0].const_val;
              D.34884 = (long unsigned int) D.34883;
              D.34885 = D.34884 * 8;
              D.34886 = D.30978 + D.34885;
              D.34887 = *D.34886;
              D.34888 = D.34887->data.op[1].vtype;
              D.34889 = mono_type_to_regmove (cfg, D.34888);
              D.34890 = (short unsigned int) D.34889;
              D.34878->opcode = D.34890;
              D.30978 = cfg->varinfo;
              D.34883 = __domain_var->data.op[0].const_val;
              D.34884 = (long unsigned int) D.34883;
              D.34885 = D.34884 * 8;
              D.34886 = D.30978 + D.34885;
              D.34887 = *D.34886;
              D.34888 = D.34887->data.op[1].vtype;
              D.34878 = iargs[0];
              type_to_eval_stack_type (cfg, D.34888, D.34878);
              D.34878 = iargs[0];
              D.30978 = cfg->varinfo;
              D.34883 = __domain_var->data.op[0].const_val;
              D.34884 = (long unsigned int) D.34883;
              D.34885 = D.34884 * 8;
              D.34886 = D.30978 + D.34885;
              D.34887 = *D.34886;
              D.34891 = D.34887->klass;
              D.34878->klass = D.34891;
              D.34878 = iargs[0];
              D.30978 = cfg->varinfo;
              D.34883 = __domain_var->data.op[0].const_val;
              D.34884 = (long unsigned int) D.34883;
              D.34885 = D.34884 * 8;
              D.34886 = D.30978 + D.34885;
              D.34887 = *D.34886;
              D.34892 = D.34887->dreg;
              D.34878->sreg1 = D.34892;
              D.34878 = iargs[0];
              D.34878 = iargs[0];
              D.34893 = D.34878->type;
              D.34894 = (<unnamed type>) D.34893;
              D.34895 = alloc_dreg (cfg, D.34894);
              D.34896 = (int) D.34895;
              D.34878->dreg = D.34896;
              D.34878 = iargs[0];
              D.34897 = D.34878->opcode;
              if (D.34897 == 427) goto <D.34898>; else goto <D.34899>;
              <D.34898>:
              D.34878 = iargs[0];
              D.30978 = cfg->varinfo;
              D.34883 = __domain_var->data.op[0].const_val;
              D.34884 = (long unsigned int) D.34883;
              D.34885 = D.34884 * 8;
              D.34886 = D.30978 + D.34885;
              D.34887 = *D.34886;
              D.34888 = D.34887->data.op[1].vtype;
              D.34900 = mono_class_from_mono_type (D.34888);
              D.34878->klass = D.34900;
              <D.34899>:
            }
            goto <D.34875>;
            <D.34874>:
            D.30241 = cfg->mempool;
            D.34901 = mono_mempool_alloc (D.30241, 80);
            iargs[0] = D.34901;
            D.34878 = iargs[0];
            D.34878 = iargs[0];
            D.34878->data.op[1].const_val = 0;
            D.34879 = D.34878->data.op[1].const_val;
            D.34878->data.op[0].const_val = D.34879;
            D.34878 = iargs[0];
            D.34878 = iargs[0];
            D.34878->prev = 0B;
            D.34880 = D.34878->prev;
            D.34878->next = D.34880;
            D.34878 = iargs[0];
            D.34878->opcode = 363;
            D.34878 = iargs[0];
            D.34878->flags = 0;
            D.34878 = iargs[0];
            D.34878->type = 0;
            D.34878 = iargs[0];
            D.34878->dreg = -1;
            D.34878 = iargs[0];
            D.34878 = iargs[0];
            D.34878 = iargs[0];
            D.34878->sreg3 = -1;
            D.34881 = D.34878->sreg3;
            D.34878->sreg2 = D.34881;
            D.34882 = D.34878->sreg2;
            D.34878->sreg1 = D.34882;
            D.34878 = iargs[0];
            D.30461 = cfg->ip;
            D.34878->cil_code = D.30461;
            D.34878 = iargs[0];
            D.30267 = cfg->domain;
            D.34878->data.op[0].p = D.30267;
            D.34878 = iargs[0];
            D.34878->type = 3;
            D.34878 = iargs[0];
            D.34902 = alloc_dreg (cfg, 3);
            D.34903 = (int) D.34902;
            D.34878->dreg = D.34903;
            <D.34875>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.34904>; else goto <D.34905>;
            <D.34904>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34878 = iargs[0];
            D.30490->next = D.34878;
            D.34878 = iargs[0];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34878->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.34878 = iargs[0];
            bblock.106->last_ins = D.34878;
            goto <D.34906>;
            <D.34905>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.34878 = iargs[0];
            bblock.106->last_ins = D.34878;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.34906>:
            D.30241 = cfg->mempool;
            D.34907 = mono_mempool_alloc (D.30241, 80);
            iargs[1] = D.34907;
            D.34908 = iargs[1];
            D.34908 = iargs[1];
            D.34908->data.op[1].const_val = 0;
            D.34909 = D.34908->data.op[1].const_val;
            D.34908->data.op[0].const_val = D.34909;
            D.34908 = iargs[1];
            D.34908 = iargs[1];
            D.34908->prev = 0B;
            D.34910 = D.34908->prev;
            D.34908->next = D.34910;
            D.34908 = iargs[1];
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.34912>; else goto <D.34913>;
            <D.34912>:
            iftmp.149 = 732;
            goto <D.34914>;
            <D.34913>:
            iftmp.149 = 363;
            <D.34914>:
            D.34908->opcode = iftmp.149;
            D.34908 = iargs[1];
            D.34908->flags = 0;
            D.34908 = iargs[1];
            D.34908->type = 0;
            D.34908 = iargs[1];
            D.34908->dreg = -1;
            D.34908 = iargs[1];
            D.34908 = iargs[1];
            D.34908 = iargs[1];
            D.34908->sreg3 = -1;
            D.34915 = D.34908->sreg3;
            D.34908->sreg2 = D.34915;
            D.34916 = D.34908->sreg2;
            D.34908->sreg1 = D.34916;
            D.34908 = iargs[1];
            D.30461 = cfg->ip;
            D.34908->cil_code = D.30461;
            D.34908 = iargs[1];
            D.34908->data.op[0].p = image;
            D.34908 = iargs[1];
            D.34908->data.op[1].src = 12B;
            D.34908 = iargs[1];
            D.34908->type = 3;
            D.34908 = iargs[1];
            D.34917 = alloc_dreg (cfg, 3);
            D.34918 = (int) D.34917;
            D.34908->dreg = D.34918;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.34919>; else goto <D.34920>;
            <D.34919>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34908 = iargs[1];
            D.30490->next = D.34908;
            D.34908 = iargs[1];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34908->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.34908 = iargs[1];
            bblock.106->last_ins = D.34908;
            goto <D.34921>;
            <D.34920>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.34908 = iargs[1];
            bblock.106->last_ins = D.34908;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.34921>:
            D.30241 = cfg->mempool;
            D.34922 = mono_mempool_alloc (D.30241, 80);
            iargs[2] = D.34922;
            D.34923 = iargs[2];
            D.34923 = iargs[2];
            D.34923->data.op[1].const_val = 0;
            D.34924 = D.34923->data.op[1].const_val;
            D.34923->data.op[0].const_val = D.34924;
            D.34923 = iargs[2];
            D.34923 = iargs[2];
            D.34923->prev = 0B;
            D.34925 = D.34923->prev;
            D.34923->next = D.34925;
            D.34923 = iargs[2];
            D.34923->opcode = 362;
            D.34923 = iargs[2];
            D.34923->flags = 0;
            D.34923 = iargs[2];
            D.34923->type = 0;
            D.34923 = iargs[2];
            D.34923->dreg = -1;
            D.34923 = iargs[2];
            D.34923 = iargs[2];
            D.34923 = iargs[2];
            D.34923->sreg3 = -1;
            D.34926 = D.34923->sreg3;
            D.34923->sreg2 = D.34926;
            D.34927 = D.34923->sreg2;
            D.34923->sreg1 = D.34927;
            D.34923 = iargs[2];
            D.30461 = cfg->ip;
            D.34923->cil_code = D.30461;
            D.34923 = iargs[2];
            D.34928 = (long int) n;
            D.34929 = D.34928 & 16777215;
            D.34923->data.op[0].const_val = D.34929;
            D.34923 = iargs[2];
            D.34923->type = 1;
            D.34923 = iargs[2];
            D.34930 = alloc_dreg (cfg, 1);
            D.34931 = (int) D.34930;
            D.34923->dreg = D.34931;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.34932>; else goto <D.34933>;
            <D.34932>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34923 = iargs[2];
            D.30490->next = D.34923;
            D.34923 = iargs[2];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34923->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.34923 = iargs[2];
            bblock.106->last_ins = D.34923;
            goto <D.34934>;
            <D.34933>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.34923 = iargs[2];
            bblock.106->last_ins = D.34923;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.34934>:
            D.34935 = mono_emit_jit_icall (cfg, mono_ldstr, &iargs);
            *sp = D.34935;
            D.30267 = cfg->domain;
            n.150 = (unsigned int) n;
            D.34937 = n.150 & 16777215;
            mono_ldstr (D.30267, image, D.34937);
          }
        finally
          {
            iargs = {CLOBBER};
          }
      }
      goto <D.34938>;
      <D.34867>:
      bblock.64 = bblock;
      D.34939 = BIT_FIELD_REF <*bblock.64, 64, 1472>;
      D.34940 = D.34939 & 140737488355328;
      if (D.34940 != 0) goto <D.34941>; else goto <D.34942>;
      <D.34941>:
      {
        struct MonoInst * iargs[2];

        try
          {
            D.32302 = mono_defaults.corlib;
            if (D.32302 == image) goto <D.34943>; else goto <D.34944>;
            <D.34943>:
            D.30241 = cfg->mempool;
            D.34945 = mono_mempool_alloc (D.30241, 80);
            iargs[0] = D.34945;
            D.34946 = iargs[0];
            D.34946 = iargs[0];
            D.34946->data.op[1].const_val = 0;
            D.34947 = D.34946->data.op[1].const_val;
            D.34946->data.op[0].const_val = D.34947;
            D.34946 = iargs[0];
            D.34946 = iargs[0];
            D.34946->prev = 0B;
            D.34948 = D.34946->prev;
            D.34946->next = D.34948;
            D.34946 = iargs[0];
            D.34946->opcode = 362;
            D.34946 = iargs[0];
            D.34946->flags = 0;
            D.34946 = iargs[0];
            D.34946->type = 0;
            D.34946 = iargs[0];
            D.34946->dreg = -1;
            D.34946 = iargs[0];
            D.34946 = iargs[0];
            D.34946 = iargs[0];
            D.34946->sreg3 = -1;
            D.34949 = D.34946->sreg3;
            D.34946->sreg2 = D.34949;
            D.34950 = D.34946->sreg2;
            D.34946->sreg1 = D.34950;
            D.34946 = iargs[0];
            D.30461 = cfg->ip;
            D.34946->cil_code = D.30461;
            D.34946 = iargs[0];
            D.34928 = (long int) n;
            D.34929 = D.34928 & 16777215;
            D.34946->data.op[0].const_val = D.34929;
            D.34946 = iargs[0];
            D.34946->type = 1;
            D.34946 = iargs[0];
            D.34951 = alloc_dreg (cfg, 1);
            D.34952 = (int) D.34951;
            D.34946->dreg = D.34952;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.34953>; else goto <D.34954>;
            <D.34953>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34946 = iargs[0];
            D.30490->next = D.34946;
            D.34946 = iargs[0];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34946->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.34946 = iargs[0];
            bblock.106->last_ins = D.34946;
            goto <D.34955>;
            <D.34954>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.34946 = iargs[0];
            bblock.106->last_ins = D.34946;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.34955>:
            D.34956 = mono_emit_jit_icall (cfg, mono_helper_ldstr_mscorlib, &iargs);
            *sp = D.34956;
            goto <D.34957>;
            <D.34944>:
            D.30241 = cfg->mempool;
            D.34958 = mono_mempool_alloc (D.30241, 80);
            iargs[0] = D.34958;
            D.34946 = iargs[0];
            D.34946 = iargs[0];
            D.34946->data.op[1].const_val = 0;
            D.34947 = D.34946->data.op[1].const_val;
            D.34946->data.op[0].const_val = D.34947;
            D.34946 = iargs[0];
            D.34946 = iargs[0];
            D.34946->prev = 0B;
            D.34948 = D.34946->prev;
            D.34946->next = D.34948;
            D.34946 = iargs[0];
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.34960>; else goto <D.34961>;
            <D.34960>:
            iftmp.151 = 732;
            goto <D.34962>;
            <D.34961>:
            iftmp.151 = 363;
            <D.34962>:
            D.34946->opcode = iftmp.151;
            D.34946 = iargs[0];
            D.34946->flags = 0;
            D.34946 = iargs[0];
            D.34946->type = 0;
            D.34946 = iargs[0];
            D.34946->dreg = -1;
            D.34946 = iargs[0];
            D.34946 = iargs[0];
            D.34946 = iargs[0];
            D.34946->sreg3 = -1;
            D.34949 = D.34946->sreg3;
            D.34946->sreg2 = D.34949;
            D.34950 = D.34946->sreg2;
            D.34946->sreg1 = D.34950;
            D.34946 = iargs[0];
            D.30461 = cfg->ip;
            D.34946->cil_code = D.30461;
            D.34946 = iargs[0];
            D.34946->data.op[0].p = image;
            D.34946 = iargs[0];
            D.34946->data.op[1].src = 12B;
            D.34946 = iargs[0];
            D.34946->type = 3;
            D.34946 = iargs[0];
            D.34963 = alloc_dreg (cfg, 3);
            D.34964 = (int) D.34963;
            D.34946->dreg = D.34964;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.34965>; else goto <D.34966>;
            <D.34965>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34946 = iargs[0];
            D.30490->next = D.34946;
            D.34946 = iargs[0];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34946->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.34946 = iargs[0];
            bblock.106->last_ins = D.34946;
            goto <D.34967>;
            <D.34966>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.34946 = iargs[0];
            bblock.106->last_ins = D.34946;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.34967>:
            D.30241 = cfg->mempool;
            D.34968 = mono_mempool_alloc (D.30241, 80);
            iargs[1] = D.34968;
            D.34969 = iargs[1];
            D.34969 = iargs[1];
            D.34969->data.op[1].const_val = 0;
            D.34970 = D.34969->data.op[1].const_val;
            D.34969->data.op[0].const_val = D.34970;
            D.34969 = iargs[1];
            D.34969 = iargs[1];
            D.34969->prev = 0B;
            D.34971 = D.34969->prev;
            D.34969->next = D.34971;
            D.34969 = iargs[1];
            D.34969->opcode = 362;
            D.34969 = iargs[1];
            D.34969->flags = 0;
            D.34969 = iargs[1];
            D.34969->type = 0;
            D.34969 = iargs[1];
            D.34969->dreg = -1;
            D.34969 = iargs[1];
            D.34969 = iargs[1];
            D.34969 = iargs[1];
            D.34969->sreg3 = -1;
            D.34972 = D.34969->sreg3;
            D.34969->sreg2 = D.34972;
            D.34973 = D.34969->sreg2;
            D.34969->sreg1 = D.34973;
            D.34969 = iargs[1];
            D.30461 = cfg->ip;
            D.34969->cil_code = D.30461;
            D.34969 = iargs[1];
            D.34928 = (long int) n;
            D.34929 = D.34928 & 16777215;
            D.34969->data.op[0].const_val = D.34929;
            D.34969 = iargs[1];
            D.34969->type = 1;
            D.34969 = iargs[1];
            D.34974 = alloc_dreg (cfg, 1);
            D.34975 = (int) D.34974;
            D.34969->dreg = D.34975;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.34976>; else goto <D.34977>;
            <D.34976>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34969 = iargs[1];
            D.30490->next = D.34969;
            D.34969 = iargs[1];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34969->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.34969 = iargs[1];
            bblock.106->last_ins = D.34969;
            goto <D.34978>;
            <D.34977>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.34969 = iargs[1];
            bblock.106->last_ins = D.34969;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.34978>:
            D.34979 = mono_emit_jit_icall (cfg, mono_helper_ldstr, &iargs);
            *sp = D.34979;
            <D.34957>:
          }
        finally
          {
            iargs = {CLOBBER};
          }
      }
      goto <D.34980>;
      <D.34942>:
      D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.30635 = D.30634 & 33554432;
      if (D.30635 != 0) goto <D.34981>; else goto <D.34982>;
      <D.34981>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 732;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.30241 = cfg->mempool;
      n.148 = (unsigned int) n;
      D.34983 = mono_jump_info_token_new2 (D.30241, image, n.148, 0B);
      ins->data.op[0].p = D.34983;
      ins->data.op[1].p = 17B;
      ins->type = 6;
      D.34984 = mono_defaults.string_class;
      ins->klass = D.34984;
      D.34985 = alloc_dreg (cfg, 6);
      D.34986 = (int) D.34985;
      ins->dreg = D.34986;
      *sp = ins;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      if (D.30577 != 0B) goto <D.34987>; else goto <D.34988>;
      <D.34987>:
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      D.30577->next = ins;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      ins->prev = D.30577;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      goto <D.34989>;
      <D.34988>:
      bblock.64 = bblock;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      D.30577 = bblock.64->last_ins;
      bblock.64->code = D.30577;
      <D.34989>:
      goto <D.34990>;
      <D.34982>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 363;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      ins->data.op[0].p = 0B;
      ins->type = 3;
      D.34991 = alloc_dreg (cfg, 3);
      D.34992 = (int) D.34991;
      ins->dreg = D.34992;
      ins->type = 6;
      D.30267 = cfg->domain;
      n.150 = (unsigned int) n;
      D.34937 = n.150 & 16777215;
      D.34993 = mono_ldstr (D.30267, image, D.34937);
      ins->data.op[0].p = D.34993;
      D.34994 = ins->data.op[0].p;
      if (D.34994 == 0B) goto <D.34995>; else goto <D.34996>;
      <D.34995>:
      mono_cfg_set_exception (cfg, 14);
      goto exception_exit;
      <D.34996>:
      *sp = ins;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      if (D.30577 != 0B) goto <D.34997>; else goto <D.34998>;
      <D.34997>:
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      D.30577->next = ins;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      ins->prev = D.30577;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      goto <D.34999>;
      <D.34998>:
      bblock.64 = bblock;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      D.30577 = bblock.64->last_ins;
      bblock.64->code = D.30577;
      <D.34999>:
      <D.34990>:
      <D.34980>:
      <D.34938>:
      <D.34865>:
      <D.34849>:
      sp = sp + 8;
      ip = ip + 5;
      goto <D.27394>;
      <D.27716>:
      {
        struct MonoInst * iargs[2];
        struct MonoMethodSignature * fsig;
        struct MonoInst this_ins;
        struct MonoInst * alloc;
        struct MonoInst * vtable_arg;

        try
          {
            vtable_arg = 0B;
            D.31664 = ip + 5;
            if (D.31664 > end) goto <D.35000>; else goto <D.35001>;
            <D.35000>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.35002>; else goto <D.35003>;
            <D.35002>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.35004>; else goto <D.35005>;
            <D.35004>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.35005>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.35003>:
            D.35006 = mini_get_debug_options ();
            D.35007 = D.35006->break_on_unverified;
            if (D.35007 != 0) goto <D.35008>; else goto unverified;
            <D.35008>:
            raise (5);
            <D.35001>:
            D.31270 = ip + 1;
            D.31683 = MEM[(const guint32 *)D.31270];
            D.31684 = D.31683 << 24;
            D.31270 = ip + 1;
            D.31683 = MEM[(const guint32 *)D.31270];
            D.31685 = D.31683 >> 8;
            D.31686 = D.31685 & 65280;
            D.31687 = D.31684 | D.31686;
            D.31270 = ip + 1;
            D.31683 = MEM[(const guint32 *)D.31270];
            D.31688 = D.31683 << 8;
            D.31689 = D.31688 & 16711680;
            D.31690 = D.31687 | D.31689;
            D.31270 = ip + 1;
            D.31683 = MEM[(const guint32 *)D.31270];
            D.31691 = D.31683 >> 24;
            token = D.31690 | D.31691;
            cmethod = mini_get_method (cfg, method, token, 0B, generic_context);
            if (cmethod == 0B) goto <D.35009>; else goto <D.35011>;
            <D.35011>:
            D.35012 = mono_loader_get_last_error ();
            if (D.35012 != 0B) goto <D.35009>; else goto <D.35010>;
            <D.35009>:
            D.35013 = mini_get_debug_options ();
            D.35014 = D.35013->break_on_unverified;
            if (D.35014 != 0) goto <D.35015>; else goto load_error;
            <D.35015>:
            raise (5);
            <D.35010>:
            fsig = mono_method_get_signature (cmethod, image, token);
            if (fsig == 0B) goto <D.35016>; else goto <D.35017>;
            <D.35016>:
            D.35018 = mini_get_debug_options ();
            D.35019 = D.35018->break_on_unverified;
            if (D.35019 != 0) goto <D.35020>; else goto load_error;
            <D.35020>:
            raise (5);
            <D.35017>:
            mono_save_token_info (cfg, image, token, cmethod);
            D.32125 = cmethod->klass;
            D.35021 = mono_class_init (D.32125);
            if (D.35021 == 0) goto <D.35022>; else goto <D.35023>;
            <D.35022>:
            D.35024 = mini_get_debug_options ();
            D.35025 = D.35024->break_on_unverified;
            if (D.35025 != 0) goto <D.35026>; else goto <D.35027>;
            <D.35026>:
            raise (5);
            goto <D.35028>;
            <D.35027>:
            D.32125 = cmethod->klass;
            cfg->exception_ptr = D.32125;
            goto load_error;
            <D.35028>:
            <D.35023>:
            context_used = mini_method_check_context_used (cfg, cmethod);
            D.35029 = mono_security_get_mode ();
            if (D.35029 == 2) goto <D.35030>; else goto <D.35031>;
            <D.35030>:
            D.35032 = check_linkdemand (cfg, method, cmethod);
            if (D.35032 != 0) goto <D.35033>; else goto <D.35034>;
            <D.35033>:
            D.30211 = cfg->method;
            if (D.30211 != method) goto <D.35035>; else goto <D.35036>;
            <D.35035>:
            D.30183 = BIT_FIELD_REF <*method, 64, 256>;
            D.30184 = D.30183 & 4467570830351532032;
            if (D.30184 == 0) goto <D.35037>; else goto <D.35038>;
            <D.35037>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 1) goto <D.35039>; else goto <D.35040>;
            <D.35039>:
            printf ("inline failed: %s\n", "linkdemand");
            <D.35040>:
            goto inline_failure;
            <D.35038>:
            <D.35036>:
            <D.35034>:
            D.30793 = cfg->exception_type;
            if (D.30793 != 0) goto exception_exit; else goto <D.35041>;
            <D.35041>:
            goto <D.35042>;
            <D.35031>:
            D.35043 = mono_security_get_mode ();
            if (D.35043 == 1) goto <D.35044>; else goto <D.35045>;
            <D.35044>:
            bblock.64 = bblock;
            ensure_method_is_allowed_to_call_method (cfg, method, cmethod, bblock.64, ip);
            <D.35045>:
            <D.35042>:
            D.30278 = cfg->generic_sharing_context;
            if (D.30278 != 0B) goto <D.35046>; else goto <D.35047>;
            <D.35046>:
            if (cmethod != 0B) goto <D.35048>; else goto <D.35049>;
            <D.35048>:
            D.32125 = cmethod->klass;
            D.30178 = method->klass;
            if (D.32125 != D.30178) goto <D.35050>; else goto <D.35051>;
            <D.35050>:
            D.32125 = cmethod->klass;
            D.32614 = D.32125->generic_class;
            if (D.32614 != 0B) goto <D.35052>; else goto <D.35053>;
            <D.35052>:
            D.35054 = mono_method_is_generic_sharable (cmethod, 1);
            if (D.35054 != 0) goto <D.35055>; else goto <D.35056>;
            <D.35055>:
            D.32125 = cmethod->klass;
            D.35057 = mono_class_needs_cctor_run (D.32125, method);
            if (D.35057 != 0) goto <D.35058>; else goto <D.35059>;
            <D.35058>:
            D.32125 = cmethod->klass;
            emit_generic_class_init (cfg, D.32125);
            D.32125 = cmethod->klass;
            if (D.32125 == 0B) goto <D.35060>; else goto <D.35062>;
            <D.35062>:
            D.32125 = cmethod->klass;
            D.32626 = D.32125->exception_type;
            if (D.32626 != 0) goto <D.35060>; else goto <D.35061>;
            <D.35060>:
            D.32125 = cmethod->klass;
            cfg->exception_ptr = D.32125;
            D.35063 = mini_get_debug_options ();
            D.35064 = D.35063->break_on_unverified;
            if (D.35064 != 0) goto <D.35065>; else goto load_error;
            <D.35065>:
            raise (5);
            <D.35061>:
            <D.35059>:
            <D.35056>:
            <D.35053>:
            <D.35051>:
            <D.35049>:
            <D.35047>:
            D.32125 = cmethod->klass;
            D.32126 = BIT_FIELD_REF <*D.32125, 64, 256>;
            D.32127 = D.32126 & 1152921504606846976;
            if (D.32127 != 0) goto <D.35066>; else goto <D.35067>;
            <D.35066>:
            D.32125 = cmethod->klass;
            D.35068 = mono_class_generic_sharing_enabled (D.32125);
            if (D.35068 != 0) goto <D.35069>; else goto <D.35070>;
            <D.35069>:
            D.35071 = mono_method_is_generic_sharable (cmethod, 1);
            if (D.35071 != 0) goto <D.35072>; else goto <D.35073>;
            <D.35072>:
            D.32245 = BIT_FIELD_REF <*cmethod, 64, 256>;
            D.32805 = D.32245 & 2251799813685248;
            if (D.32805 != 0) goto <D.35076>; else goto <D.35074>;
            <D.35076>:
            D.35077 = mono_method_get_context (cmethod);
            D.35078 = D.35077->method_inst;
            if (D.35078 != 0B) goto <D.35079>; else goto <D.35074>;
            <D.35079>:
            D.30267 = cfg->domain;
            D.32125 = cmethod->klass;
            mono_class_vtable (D.30267, D.32125);
            D.32125 = cmethod->klass;
            if (D.32125 == 0B) goto <D.35080>; else goto <D.35082>;
            <D.35082>:
            D.32125 = cmethod->klass;
            D.32626 = D.32125->exception_type;
            if (D.32626 != 0) goto <D.35080>; else goto <D.35081>;
            <D.35080>:
            D.32125 = cmethod->klass;
            cfg->exception_ptr = D.32125;
            D.35083 = mini_get_debug_options ();
            D.35084 = D.35083->break_on_unverified;
            if (D.35084 != 0) goto <D.35085>; else goto load_error;
            <D.35085>:
            raise (5);
            <D.35081>:
            vtable_arg = emit_get_rgctx_method (cfg, context_used, cmethod, 8);
            goto <D.35075>;
            <D.35074>:
            if (context_used != 0) goto <D.35086>; else goto <D.35087>;
            <D.35086>:
            D.32125 = cmethod->klass;
            vtable_arg = emit_get_rgctx_klass (cfg, context_used, D.32125, 2);
            goto <D.35088>;
            <D.35087>:
            {
              struct MonoVTable * vtable;

              D.30267 = cfg->domain;
              D.32125 = cmethod->klass;
              vtable = mono_class_vtable (D.30267, D.32125);
              D.32125 = cmethod->klass;
              if (D.32125 == 0B) goto <D.35089>; else goto <D.35091>;
              <D.35091>:
              D.32125 = cmethod->klass;
              D.32626 = D.32125->exception_type;
              if (D.32626 != 0) goto <D.35089>; else goto <D.35090>;
              <D.35089>:
              D.32125 = cmethod->klass;
              cfg->exception_ptr = D.32125;
              D.35092 = mini_get_debug_options ();
              D.35093 = D.35092->break_on_unverified;
              if (D.35093 != 0) goto <D.35094>; else goto load_error;
              <D.35094>:
              raise (5);
              <D.35090>:
              D.30241 = cfg->mempool;
              vtable_arg = mono_mempool_alloc (D.30241, 80);
              vtable_arg->data.op[1].const_val = 0;
              D.35095 = vtable_arg->data.op[1].const_val;
              vtable_arg->data.op[0].const_val = D.35095;
              vtable_arg->prev = 0B;
              D.35096 = vtable_arg->prev;
              vtable_arg->next = D.35096;
              D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.30635 = D.30634 & 33554432;
              if (D.30635 != 0) goto <D.35098>; else goto <D.35099>;
              <D.35098>:
              iftmp.152 = 732;
              goto <D.35100>;
              <D.35099>:
              iftmp.152 = 363;
              <D.35100>:
              vtable_arg->opcode = iftmp.152;
              vtable_arg->flags = 0;
              vtable_arg->type = 0;
              vtable_arg->dreg = -1;
              vtable_arg->sreg3 = -1;
              D.35101 = vtable_arg->sreg3;
              vtable_arg->sreg2 = D.35101;
              D.35102 = vtable_arg->sreg2;
              vtable_arg->sreg1 = D.35102;
              D.30461 = cfg->ip;
              vtable_arg->cil_code = D.30461;
              D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.30635 = D.30634 & 33554432;
              if (D.30635 != 0) goto <D.35104>; else goto <D.35105>;
              <D.35104>:
              iftmp.153 = vtable->klass;
              goto <D.35106>;
              <D.35105>:
              iftmp.153 = vtable;
              <D.35106>:
              vtable_arg->data.op[0].p = iftmp.153;
              vtable_arg->data.op[1].src = 14B;
              vtable_arg->type = 3;
              D.35107 = alloc_dreg (cfg, 3);
              D.35108 = (int) D.35107;
              vtable_arg->dreg = D.35108;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.35109>; else goto <D.35110>;
              <D.35109>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = vtable_arg;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              vtable_arg->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = vtable_arg;
              goto <D.35111>;
              <D.35110>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = vtable_arg;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.35111>:
            }
            <D.35088>:
            <D.35075>:
            <D.35073>:
            <D.35070>:
            <D.35067>:
            D.35112 = fsig->param_count;
            n = (int) D.35112;
            sp.71 = (long int) sp;
            stack_start.72 = (long int) stack_start;
            D.31013 = sp.71 - stack_start.72;
            D.31014 = D.31013 /[ex] 8;
            D.32275 = (long int) n;
            if (D.31014 < D.32275) goto <D.35113>; else goto <D.35114>;
            <D.35113>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.35115>; else goto <D.35116>;
            <D.35115>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.35117>; else goto <D.35118>;
            <D.35117>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.35118>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.35116>:
            D.35119 = mini_get_debug_options ();
            D.35120 = D.35119->break_on_unverified;
            if (D.35120 != 0) goto <D.35121>; else goto unverified;
            <D.35121>:
            raise (5);
            <D.35114>:
            bblock.64 = bblock;
            D.34939 = BIT_FIELD_REF <*bblock.64, 64, 1472>;
            D.34940 = D.34939 & 140737488355328;
            if (D.34940 != 0) goto <D.35125>; else goto <D.35126>;
            <D.35125>:
            D.32125 = cmethod->klass;
            D.32301 = D.32125->image;
            D.32302 = mono_defaults.corlib;
            if (D.32301 == D.32302) goto <D.35127>; else goto <D.35128>;
            <D.35127>:
            D.32125 = cmethod->klass;
            D.35129 = is_exception_class (D.32125);
            if (D.35129 != 0) goto <D.35130>; else goto <D.35131>;
            <D.35130>:
            if (n <= 2) goto <D.35132>; else goto <D.35133>;
            <D.35132>:
            if (n <= 0) goto <D.35124>; else goto <D.35134>;
            <D.35134>:
            D.35135 = fsig->params[0];
            D.35136 = BIT_FIELD_REF <*D.35135, 64, 64>;
            D.35137 = D.35136 & 280384055017472;
            if (D.35137 == 15393162788864) goto <D.35124>; else goto <D.35123>;
            <D.35124>:
            if (n <= 1) goto <D.35122>; else goto <D.35138>;
            <D.35138>:
            D.35139 = fsig->params[1];
            D.35140 = BIT_FIELD_REF <*D.35139, 64, 64>;
            D.35141 = D.35140 & 280384055017472;
            if (D.35141 == 15393162788864) goto <D.35122>; else goto <D.35123>;
            <D.35122>:
            {
              struct MonoInst * iargs[3];

              try
                {
                  D.35142 = vtable_arg != 0B;
                  D.35143 = (long int) D.35142;
                  D.35144 = __builtin_expect (D.35143, 0);
                  if (D.35144 != 0) goto <D.35145>; else goto <D.35146>;
                  <D.35145>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9300, "!vtable_arg");
                  <D.35146>:
                  D.31166 = (long unsigned int) n;
                  D.31167 = D.31166 * 8;
                  D.32285 = -D.31167;
                  sp = sp + D.32285;
                  D.30241 = cfg->mempool;
                  D.35147 = mono_mempool_alloc (D.30241, 80);
                  iargs[0] = D.35147;
                  D.35148 = iargs[0];
                  D.35148 = iargs[0];
                  D.35148->data.op[1].const_val = 0;
                  D.35149 = D.35148->data.op[1].const_val;
                  D.35148->data.op[0].const_val = D.35149;
                  D.35148 = iargs[0];
                  D.35148 = iargs[0];
                  D.35148->prev = 0B;
                  D.35150 = D.35148->prev;
                  D.35148->next = D.35150;
                  D.35148 = iargs[0];
                  D.35148->opcode = 362;
                  D.35148 = iargs[0];
                  D.35148->flags = 0;
                  D.35148 = iargs[0];
                  D.35148->type = 0;
                  D.35148 = iargs[0];
                  D.35148->dreg = -1;
                  D.35148 = iargs[0];
                  D.35148 = iargs[0];
                  D.35148 = iargs[0];
                  D.35148->sreg3 = -1;
                  D.35151 = D.35148->sreg3;
                  D.35148->sreg2 = D.35151;
                  D.35152 = D.35148->sreg2;
                  D.35148->sreg1 = D.35152;
                  D.35148 = iargs[0];
                  D.30461 = cfg->ip;
                  D.35148->cil_code = D.30461;
                  D.35148 = iargs[0];
                  D.32125 = cmethod->klass;
                  D.35153 = D.32125->type_token;
                  D.35154 = (long int) D.35153;
                  D.35148->data.op[0].const_val = D.35154;
                  D.35148 = iargs[0];
                  D.35148->type = 1;
                  D.35148 = iargs[0];
                  D.35155 = alloc_dreg (cfg, 1);
                  D.35156 = (int) D.35155;
                  D.35148->dreg = D.35156;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.35157>; else goto <D.35158>;
                  <D.35157>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.35148 = iargs[0];
                  D.30490->next = D.35148;
                  D.35148 = iargs[0];
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.35148->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  D.35148 = iargs[0];
                  bblock.106->last_ins = D.35148;
                  goto <D.35159>;
                  <D.35158>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  D.35148 = iargs[0];
                  bblock.106->last_ins = D.35148;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.35159>:
                  switch (n) <default: <D.27728>, case 0: <D.27724>, case 1: <D.27726>, case 2: <D.27727>>
                  <D.27724>:
                  sp.154 = sp;
                  sp = sp.154 + 8;
                  D.35161 = mono_emit_jit_icall (cfg, mono_create_corlib_exception_0, &iargs);
                  *sp.154 = D.35161;
                  goto <D.27725>;
                  <D.27726>:
                  D.31240 = *sp;
                  iargs[1] = D.31240;
                  sp.155 = sp;
                  sp = sp.155 + 8;
                  D.35163 = mono_emit_jit_icall (cfg, mono_create_corlib_exception_1, &iargs);
                  *sp.155 = D.35163;
                  goto <D.27725>;
                  <D.27727>:
                  D.31240 = *sp;
                  iargs[1] = D.31240;
                  D.35164 = MEM[(struct MonoInst * *)sp + 8B];
                  iargs[2] = D.35164;
                  sp.156 = sp;
                  sp = sp.156 + 8;
                  D.35166 = mono_emit_jit_icall (cfg, mono_create_corlib_exception_2, &iargs);
                  *sp.156 = D.35166;
                  goto <D.27725>;
                  <D.27728>:
                  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 9319);
                  <D.27725>:
                  ip = ip + 5;
                  inline_costs = inline_costs + 5;
                  goto <D.27394>;
                }
              finally
                {
                  iargs = {CLOBBER};
                }
            }
            <D.35123>:
            <D.35133>:
            <D.35131>:
            <D.35128>:
            <D.35126>:
            goto <D.27730>;
            <D.27729>:
            sp = sp + 18446744073709551608;
            D.32378 = sp + 8;
            D.31240 = *sp;
            *D.32378 = D.31240;
            <D.27730>:
            n.157 = n;
            n = n.157 + -1;
            if (n.157 != 0) goto <D.27729>; else goto <D.27731>;
            <D.27731>:
            this_ins.type = 6;
            *sp = &this_ins;
            D.35168 = check_call_signature (cfg, fsig, sp);
            if (D.35168 != 0) goto <D.35169>; else goto <D.35170>;
            <D.35169>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.35171>; else goto <D.35172>;
            <D.35171>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.35173>; else goto <D.35174>;
            <D.35173>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.35174>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.35172>:
            D.35175 = mini_get_debug_options ();
            D.35176 = D.35175->break_on_unverified;
            if (D.35176 != 0) goto <D.35177>; else goto unverified;
            <D.35177>:
            raise (5);
            <D.35170>:
            iargs[0] = 0B;
            D.32125 = cmethod->klass;
            D.35178 = mini_class_is_system_array (D.32125);
            if (D.35178 != 0) goto <D.35179>; else goto <D.35180>;
            <D.35179>:
            D.35142 = vtable_arg != 0B;
            D.35143 = (long int) D.35142;
            D.35144 = __builtin_expect (D.35143, 0);
            if (D.35144 != 0) goto <D.35181>; else goto <D.35182>;
            <D.35181>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9342, "!vtable_arg");
            <D.35182>:
            D.35183 = emit_get_rgctx_method (cfg, context_used, cmethod, 5);
            *sp = D.35183;
            D.35112 = fsig->param_count;
            if (D.35112 == 1) goto <D.35184>; else goto <D.35185>;
            <D.35184>:
            alloc = mono_emit_jit_icall (cfg, mono_array_new_1, sp);
            goto <D.35186>;
            <D.35185>:
            D.35112 = fsig->param_count;
            if (D.35112 == 2) goto <D.35187>; else goto <D.35188>;
            <D.35187>:
            alloc = mono_emit_jit_icall (cfg, mono_array_new_2, sp);
            goto <D.35189>;
            <D.35188>:
            D.35112 = fsig->param_count;
            if (D.35112 == 3) goto <D.35190>; else goto <D.35191>;
            <D.35190>:
            alloc = mono_emit_jit_icall (cfg, mono_array_new_3, sp);
            goto <D.35192>;
            <D.35191>:
            D.35112 = fsig->param_count;
            if (D.35112 == 4) goto <D.35193>; else goto <D.35194>;
            <D.35193>:
            alloc = mono_emit_jit_icall (cfg, mono_array_new_4, sp);
            goto <D.35195>;
            <D.35194>:
            D.35112 = fsig->param_count;
            D.35196 = (int) D.35112;
            alloc = handle_array_new (cfg, D.35196, sp, ip);
            <D.35195>:
            <D.35192>:
            <D.35189>:
            <D.35186>:
            goto <D.35197>;
            <D.35180>:
            D.32245 = BIT_FIELD_REF <*cmethod, 64, 256>;
            D.32246 = D.32245 & 72057594037927936;
            if (D.32246 != 0) goto <D.35198>; else goto <D.35199>;
            <D.35198>:
            D.35200 = context_used != 0;
            D.35201 = (long int) D.35200;
            D.35202 = __builtin_expect (D.35201, 0);
            if (D.35202 != 0) goto <D.35203>; else goto <D.35204>;
            <D.35203>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9359, "!context_used");
            <D.35204>:
            D.35142 = vtable_arg != 0B;
            D.35143 = (long int) D.35142;
            D.35144 = __builtin_expect (D.35143, 0);
            if (D.35144 != 0) goto <D.35205>; else goto <D.35206>;
            <D.35205>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9360, "!vtable_arg");
            <D.35206>:
            D.30241 = cfg->mempool;
            D.35207 = mono_mempool_alloc (D.30241, 80);
            *sp = D.35207;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->data.op[1].const_val = 0;
            D.32916 = D.31240->data.op[1].const_val;
            D.31240->data.op[0].const_val = D.32916;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->prev = 0B;
            D.32917 = D.31240->prev;
            D.31240->next = D.32917;
            D.31240 = *sp;
            D.31240->opcode = 363;
            D.31240 = *sp;
            D.31240->flags = 0;
            D.31240 = *sp;
            D.31240->type = 0;
            D.31240 = *sp;
            D.31240->dreg = -1;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->sreg3 = -1;
            D.32918 = D.31240->sreg3;
            D.31240->sreg2 = D.32918;
            D.32919 = D.31240->sreg2;
            D.31240->sreg1 = D.32919;
            D.31240 = *sp;
            D.30461 = cfg->ip;
            D.31240->cil_code = D.30461;
            D.31240 = *sp;
            D.31240->data.op[0].p = 0B;
            D.31240 = *sp;
            D.31240->type = 3;
            D.31240 = *sp;
            D.35208 = alloc_dreg (cfg, 3);
            D.35209 = (int) D.35208;
            D.31240->dreg = D.35209;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.35210>; else goto <D.35211>;
            <D.35210>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240 = *sp;
            D.30490->next = D.31240;
            D.31240 = *sp;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            goto <D.35212>;
            <D.35211>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.35212>:
            alloc = mono_emit_method_call_full (cfg, cmethod, fsig, 0, sp, 0B, 0B, 0B);
            goto <D.35213>;
            <D.35199>:
            {
              struct MonoInst * callvirt_this_arg;

              callvirt_this_arg = 0B;
              D.32125 = cmethod->klass;
              D.32126 = BIT_FIELD_REF <*D.32125, 64, 256>;
              D.32127 = D.32126 & 1152921504606846976;
              if (D.32127 != 0) goto <D.35214>; else goto <D.35215>;
              <D.35214>:
              D.32125 = cmethod->klass;
              D.35216 = &D.32125->byval_arg;
              D.35217 = mono_compile_create_var (cfg, D.35216, 329);
              iargs[0] = D.35217;
              D.35218 = iargs[0];
              D.35219 = D.35218->dreg;
              D.32125 = cmethod->klass;
              D.35216 = &D.32125->byval_arg;
              emit_init_rvar (cfg, D.35219, D.35216);
              D.30241 = cfg->mempool;
              D.35220 = mono_mempool_alloc (D.30241, 80);
              *sp = D.35220;
              D.31240 = *sp;
              D.31240 = *sp;
              D.31240->data.op[1].const_val = 0;
              D.32916 = D.31240->data.op[1].const_val;
              D.31240->data.op[0].const_val = D.32916;
              D.31240 = *sp;
              D.31240 = *sp;
              D.31240->prev = 0B;
              D.32917 = D.31240->prev;
              D.31240->next = D.32917;
              D.31240 = *sp;
              D.31240->opcode = 314;
              D.31240 = *sp;
              D.31240->flags = 0;
              D.31240 = *sp;
              D.31240->type = 0;
              D.31240 = *sp;
              D.31240->dreg = -1;
              D.31240 = *sp;
              D.31240 = *sp;
              D.31240 = *sp;
              D.31240->sreg3 = -1;
              D.32918 = D.31240->sreg3;
              D.31240->sreg2 = D.32918;
              D.32919 = D.31240->sreg2;
              D.31240->sreg1 = D.32919;
              D.31240 = *sp;
              D.30461 = cfg->ip;
              D.31240->cil_code = D.30461;
              D.31240 = *sp;
              D.30978 = cfg->varinfo;
              D.35218 = iargs[0];
              D.35221 = D.35218->data.op[0].const_val;
              D.35222 = (long unsigned int) D.35221;
              D.35223 = D.35222 * 8;
              D.35224 = D.30978 + D.35223;
              D.35225 = *D.35224;
              D.31240->data.op[0].p = D.35225;
              D.30978 = cfg->varinfo;
              D.35218 = iargs[0];
              D.35221 = D.35218->data.op[0].const_val;
              D.35222 = (long unsigned int) D.35221;
              D.35223 = D.35222 * 8;
              D.35224 = D.30978 + D.35223;
              D.35225 = *D.35224;
              D.30978 = cfg->varinfo;
              D.35218 = iargs[0];
              D.35221 = D.35218->data.op[0].const_val;
              D.35222 = (long unsigned int) D.35221;
              D.35223 = D.35222 * 8;
              D.35224 = D.30978 + D.35223;
              D.35225 = *D.35224;
              D.35226 = D.35225->flags;
              D.35227 = D.35226 | 16;
              D.35225->flags = D.35227;
              D.31240 = *sp;
              D.31240->type = 5;
              D.31240 = *sp;
              D.30978 = cfg->varinfo;
              D.35218 = iargs[0];
              D.35221 = D.35218->data.op[0].const_val;
              D.35222 = (long unsigned int) D.35221;
              D.35223 = D.35222 * 8;
              D.35224 = D.30978 + D.35223;
              D.35225 = *D.35224;
              D.35228 = D.35225->klass;
              D.31240->klass = D.35228;
              D.31240 = *sp;
              D.35229 = alloc_dreg (cfg, 5);
              D.35230 = (int) D.35229;
              D.31240->dreg = D.35230;
              cfg->has_indirection = 1;
              D.30389 = cfg->gsharedvt;
              D.31326 = D.30389 != 0;
              D.31327 = (long int) D.31326;
              D.31328 = __builtin_expect (D.31327, 0);
              if (D.31328 != 0) goto <D.35231>; else goto <D.35232>;
              <D.35231>:
              D.30978 = cfg->varinfo;
              D.35218 = iargs[0];
              D.35221 = D.35218->data.op[0].const_val;
              D.35222 = (long unsigned int) D.35221;
              D.35223 = D.35222 * 8;
              D.35224 = D.30978 + D.35223;
              D.35225 = *D.35224;
              D.35233 = D.35225->data.op[1].vtype;
              D.35234 = mini_is_gsharedvt_variable_type (cfg, D.35233);
              if (D.35234 != 0) goto <D.35235>; else goto <D.35236>;
              <D.35235>:
              handle_gsharedvt_ldaddr (cfg);
              <D.35236>:
              <D.35232>:
              if (0 != 0) goto <D.35237>; else goto <D.35238>;
              <D.35237>:
              {
                struct MonoInst * var1;
                struct MonoInst * var2;

                D.30978 = cfg->varinfo;
                D.35218 = iargs[0];
                D.35221 = D.35218->data.op[0].const_val;
                D.35222 = (long unsigned int) D.35221;
                D.35223 = D.35222 * 8;
                D.35224 = D.30978 + D.35223;
                D.35225 = *D.35224;
                D.35240 = D.35225->dreg;
                D.35241 = D.35240 + 1;
                D.35242 = (unsigned int) D.35241;
                D.31341 = cfg->vreg_to_inst_len;
                if (D.35242 < D.31341) goto <D.35243>; else goto <D.35244>;
                <D.35243>:
                D.31344 = cfg->vreg_to_inst;
                D.30978 = cfg->varinfo;
                D.35218 = iargs[0];
                D.35221 = D.35218->data.op[0].const_val;
                D.35222 = (long unsigned int) D.35221;
                D.35223 = D.35222 * 8;
                D.35224 = D.30978 + D.35223;
                D.35225 = *D.35224;
                D.35240 = D.35225->dreg;
                D.35245 = (sizetype) D.35240;
                D.35246 = D.35245 + 1;
                D.35247 = D.35246 * 8;
                D.35248 = D.31344 + D.35247;
                iftmp.158 = *D.35248;
                goto <D.35249>;
                <D.35244>:
                iftmp.158 = 0B;
                <D.35249>:
                var1 = iftmp.158;
                D.30978 = cfg->varinfo;
                D.35218 = iargs[0];
                D.35221 = D.35218->data.op[0].const_val;
                D.35222 = (long unsigned int) D.35221;
                D.35223 = D.35222 * 8;
                D.35224 = D.30978 + D.35223;
                D.35225 = *D.35224;
                D.35240 = D.35225->dreg;
                D.35251 = D.35240 + 2;
                D.35252 = (unsigned int) D.35251;
                D.31341 = cfg->vreg_to_inst_len;
                if (D.35252 < D.31341) goto <D.35253>; else goto <D.35254>;
                <D.35253>:
                D.31344 = cfg->vreg_to_inst;
                D.30978 = cfg->varinfo;
                D.35218 = iargs[0];
                D.35221 = D.35218->data.op[0].const_val;
                D.35222 = (long unsigned int) D.35221;
                D.35223 = D.35222 * 8;
                D.35224 = D.30978 + D.35223;
                D.35225 = *D.35224;
                D.35240 = D.35225->dreg;
                D.35245 = (sizetype) D.35240;
                D.35255 = D.35245 + 2;
                D.35256 = D.35255 * 8;
                D.35257 = D.31344 + D.35256;
                iftmp.159 = *D.35257;
                goto <D.35258>;
                <D.35254>:
                iftmp.159 = 0B;
                <D.35258>:
                var2 = iftmp.159;
                D.35259 = var1 == 0B;
                D.35260 = (long int) D.35259;
                D.35261 = __builtin_expect (D.35260, 0);
                if (D.35261 != 0) goto <D.35262>; else goto <D.35263>;
                <D.35262>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9371, "var1");
                <D.35263>:
                D.35264 = var2 == 0B;
                D.35265 = (long int) D.35264;
                D.35266 = __builtin_expect (D.35265, 0);
                if (D.35266 != 0) goto <D.35267>; else goto <D.35268>;
                <D.35267>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9371, "var2");
                <D.35268>:
                D.35269 = var1->flags;
                D.35270 = D.35269 | 16;
                var1->flags = D.35270;
                D.35271 = var2->flags;
                D.35272 = D.35271 | 16;
                var2->flags = D.35272;
              }
              <D.35238>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.35273>; else goto <D.35274>;
              <D.35273>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.31240 = *sp;
              D.30490->next = D.31240;
              D.31240 = *sp;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.31240->prev = D.30490;
              bblock.106 = cfg->cbb;
              D.31240 = *sp;
              bblock.106->last_ins = D.31240;
              goto <D.35275>;
              <D.35274>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              D.31240 = *sp;
              bblock.106->last_ins = D.31240;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.35275>:
              alloc = 0B;
              goto <D.35276>;
              <D.35215>:
              if (context_used != 0) goto <D.35277>; else goto <D.35278>;
              <D.35277>:
              D.32125 = cmethod->klass;
              alloc = handle_alloc (cfg, D.32125, 0, context_used);
              *sp = alloc;
              goto <D.35279>;
              <D.35278>:
              {
                struct MonoVTable * vtable;

                vtable = 0B;
                D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
                D.30635 = D.30634 & 33554432;
                if (D.30635 == 0) goto <D.35280>; else goto <D.35281>;
                <D.35280>:
                D.30267 = cfg->domain;
                D.32125 = cmethod->klass;
                vtable = mono_class_vtable (D.30267, D.32125);
                <D.35281>:
                D.32125 = cmethod->klass;
                if (D.32125 == 0B) goto <D.35282>; else goto <D.35284>;
                <D.35284>:
                D.32125 = cmethod->klass;
                D.32626 = D.32125->exception_type;
                if (D.32626 != 0) goto <D.35282>; else goto <D.35283>;
                <D.35282>:
                D.32125 = cmethod->klass;
                cfg->exception_ptr = D.32125;
                D.35285 = mini_get_debug_options ();
                D.35286 = D.35285->break_on_unverified;
                if (D.35286 != 0) goto <D.35287>; else goto load_error;
                <D.35287>:
                raise (5);
                <D.35283>:
                D.32125 = cmethod->klass;
                D.35288 = mini_field_access_needs_cctor_run (cfg, method, D.32125, vtable);
                if (D.35288 != 0) goto <D.35289>; else goto <D.35290>;
                <D.35289>:
                D.32125 = cmethod->klass;
                D.35291 = monoeg_g_slist_find (class_inits, D.32125);
                if (D.35291 == 0B) goto <D.35292>; else goto <D.35293>;
                <D.35292>:
                D.32125 = cmethod->klass;
                helper_sig_class_init_trampoline.160 = helper_sig_class_init_trampoline;
                mono_emit_abs_call (cfg, 15, D.32125, helper_sig_class_init_trampoline.160, 0B);
                D.30322 = cfg->verbose_level;
                if (D.30322 > 2) goto <D.35295>; else goto <D.35296>;
                <D.35295>:
                D.32125 = cmethod->klass;
                D.35297 = D.32125->name_space;
                D.32125 = cmethod->klass;
                D.35298 = D.32125->name;
                printf ("class %s.%s needs init call for ctor\n", D.35297, D.35298);
                <D.35296>:
                D.32125 = cmethod->klass;
                class_inits = monoeg_g_slist_prepend (class_inits, D.32125);
                <D.35293>:
                <D.35290>:
                D.32125 = cmethod->klass;
                alloc = handle_alloc (cfg, D.32125, 0, 0);
                *sp = alloc;
              }
              <D.35279>:
              <D.35276>:
              D.30793 = cfg->exception_type;
              if (D.30793 != 0) goto exception_exit; else goto <D.35299>;
              <D.35299>:
              if (alloc != 0B) goto <D.35300>; else goto <D.35301>;
              <D.35300>:
              {
                struct MonoInst * inst;

                D.30241 = cfg->mempool;
                inst = mono_mempool_alloc (D.30241, 80);
                inst->data.op[1].const_val = 0;
                D.35302 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.35302;
                inst->prev = 0B;
                D.35303 = inst->prev;
                inst->next = D.35303;
                inst->opcode = 799;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.35304 = inst->sreg3;
                inst->sreg2 = D.35304;
                D.35305 = inst->sreg2;
                inst->sreg1 = D.35305;
                D.30461 = cfg->ip;
                inst->cil_code = D.30461;
                inst->dreg = -1;
                D.35306 = alloc->dreg;
                inst->sreg1 = D.35306;
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                if (D.30490 != 0B) goto <D.35307>; else goto <D.35308>;
                <D.35307>:
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                D.30490->next = inst;
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                inst->prev = D.30490;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                goto <D.35309>;
                <D.35308>:
                bblock.106 = cfg->cbb;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                D.30490 = bblock.106->last_ins;
                bblock.106->code = D.30490;
                <D.35309>:
              }
              <D.35301>:
              D.32125 = cmethod->klass;
              D.32126 = BIT_FIELD_REF <*D.32125, 64, 256>;
              D.32168 = D.32126 & 2199023255552;
              if (D.32168 != 0) goto <D.35310>; else goto <D.35311>;
              <D.35310>:
              callvirt_this_arg = *sp;
              <D.35311>:
              if (cmethod != 0B) goto <D.35314>; else goto <D.35312>;
              <D.35314>:
              D.30632 = cfg->opt;
              D.32600 = D.30632 & 2048;
              if (D.32600 != 0) goto <D.35315>; else goto <D.35312>;
              <D.35315>:
              ins = mini_emit_inst_for_ctor (cfg, cmethod, fsig, sp);
              if (ins != 0B) goto <D.35316>; else goto <D.35312>;
              <D.35316>:
              D.35317 = fsig->ret;
              D.35318 = mono_type_is_void (D.35317);
              if (D.35318 == 0) goto <D.35319>; else goto <D.35320>;
              <D.35319>:
              D.35317 = fsig->ret;
              type_to_eval_stack_type (cfg, D.35317, ins);
              *sp = ins;
              sp = sp + 8;
              <D.35320>:
              D.30793 = cfg->exception_type;
              if (D.30793 != 0) goto exception_exit; else goto <D.35321>;
              <D.35321>:
              goto <D.35313>;
              <D.35312>:
              D.30632 = cfg->opt;
              D.32993 = D.30632 & 4;
              if (D.32993 != 0) goto <D.35324>; else goto <D.35322>;
              <D.35324>:
              if (cmethod != 0B) goto <D.35325>; else goto <D.35322>;
              <D.35325>:
              if (context_used == 0) goto <D.35326>; else goto <D.35322>;
              <D.35326>:
              if (vtable_arg == 0B) goto <D.35327>; else goto <D.35322>;
              <D.35327>:
              if (disable_inline == 0) goto <D.35328>; else goto <D.35322>;
              <D.35328>:
              D.35329 = mono_method_check_inlining (cfg, cmethod);
              if (D.35329 != 0) goto <D.35330>; else goto <D.35322>;
              <D.35330>:
              D.32125 = cmethod->klass;
              D.35331 = mono_defaults.exception_class;
              D.35332 = mono_class_is_subclass_of (D.32125, D.35331, 0);
              if (D.35332 == 0) goto <D.35333>; else goto <D.35322>;
              <D.35333>:
              D.35334 = monoeg_g_list_find (dont_inline, cmethod);
              if (D.35334 == 0B) goto <D.35335>; else goto <D.35322>;
              <D.35335>:
              {
                int costs;

                D.30408 = cfg->real_offset;
                costs = inline_method (cfg, cmethod, fsig, sp, ip, D.30408, dont_inline, 0);
                if (costs != 0) goto <D.35336>; else goto <D.35337>;
                <D.35336>:
                D.30408 = cfg->real_offset;
                D.33020 = D.30408 + 5;
                cfg->real_offset = D.33020;
                bblock.106 = cfg->cbb;
                bblock = bblock.106;
                D.35338 = costs + -5;
                inline_costs = D.35338 + inline_costs;
                goto <D.35339>;
                <D.35337>:
                D.30211 = cfg->method;
                if (D.30211 != method) goto <D.35340>; else goto <D.35341>;
                <D.35340>:
                D.30183 = BIT_FIELD_REF <*method, 64, 256>;
                D.30184 = D.30183 & 4467570830351532032;
                if (D.30184 == 0) goto <D.35342>; else goto <D.35343>;
                <D.35342>:
                D.30322 = cfg->verbose_level;
                if (D.30322 > 1) goto <D.35344>; else goto <D.35345>;
                <D.35344>:
                printf ("inline failed: %s\n", "inline failure");
                <D.35345>:
                goto inline_failure;
                <D.35343>:
                <D.35341>:
                D.30389 = cfg->gsharedvt;
                if (D.30389 != 0) goto <D.35346>; else goto <D.35347>;
                <D.35346>:
                D.35348 = mini_is_gsharedvt_signature (cfg, fsig);
                if (D.35348 != 0) goto <D.35349>; else goto <D.35350>;
                <D.35349>:
                D.30389 = cfg->gsharedvt;
                if (D.30389 != 0) goto <D.35351>; else goto <D.35352>;
                <D.35351>:
                D.30178 = method->klass;
                D.31934 = D.30178->name_space;
                D.30178 = method->klass;
                D.31935 = D.30178->name;
                D.31936 = method->name;
                D.31937 = method->signature;
                D.31938 = D.31937->param_count;
                D.31939 = (int) D.31938;
                D.31121 = *ip;
                D.31122 = (int) D.31121;
                D.35353 = mono_opcode_name (D.31122);
                D.35354 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.31934, D.31935, D.31936, D.31939, D.35353, "method-to-ir.c", 9439);
                cfg->exception_message = D.35354;
                D.30322 = cfg->verbose_level;
                if (D.30322 > 1) goto <D.35355>; else goto <D.35356>;
                <D.35355>:
                D.31944 = cfg->exception_message;
                printf ("%s\n", D.31944);
                <D.35356>:
                mono_cfg_set_exception (cfg, 11);
                goto exception_exit;
                <D.35352>:
                <D.35350>:
                <D.35347>:
                mono_emit_method_call_full (cfg, cmethod, fsig, 0, sp, callvirt_this_arg, 0B, 0B);
                <D.35339>:
              }
              goto <D.35323>;
              <D.35322>:
              D.30389 = cfg->gsharedvt;
              if (D.30389 != 0) goto <D.35359>; else goto <D.35357>;
              <D.35359>:
              D.35360 = mini_is_gsharedvt_signature (cfg, fsig);
              if (D.35360 != 0) goto <D.35361>; else goto <D.35357>;
              <D.35361>:
              {
                struct MonoInst * addr;

                addr = emit_get_rgctx_gsharedvt_call (cfg, context_used, fsig, cmethod, 16);
                mono_emit_calli (cfg, fsig, sp, addr, 0B, vtable_arg);
              }
              goto <D.35358>;
              <D.35357>:
              if (context_used != 0) goto <D.35365>; else goto <D.35362>;
              <D.35365>:
              D.35366 = mono_method_is_generic_sharable (cmethod, 1);
              if (D.35366 == 0) goto <D.35363>; else goto <D.35367>;
              <D.35367>:
              D.32125 = cmethod->klass;
              D.35368 = mono_class_generic_sharing_enabled (D.32125);
              if (D.35368 == 0) goto <D.35363>; else goto <D.35362>;
              <D.35363>:
              {
                struct MonoInst * cmethod_addr;

                cmethod_addr = emit_get_rgctx_method (cfg, context_used, cmethod, 6);
                mono_emit_calli (cfg, fsig, sp, cmethod_addr, 0B, vtable_arg);
              }
              goto <D.35364>;
              <D.35362>:
              D.30211 = cfg->method;
              if (D.30211 != method) goto <D.35369>; else goto <D.35370>;
              <D.35369>:
              D.30183 = BIT_FIELD_REF <*method, 64, 256>;
              D.30184 = D.30183 & 4467570830351532032;
              if (D.30184 == 0) goto <D.35371>; else goto <D.35372>;
              <D.35371>:
              D.30322 = cfg->verbose_level;
              if (D.30322 > 1) goto <D.35373>; else goto <D.35374>;
              <D.35373>:
              printf ("inline failed: %s\n", "ctor call");
              <D.35374>:
              goto inline_failure;
              <D.35372>:
              <D.35370>:
              ins = mono_emit_method_call_full (cfg, cmethod, fsig, 0, sp, callvirt_this_arg, 0B, vtable_arg);
              <D.35364>:
              <D.35358>:
              <D.35323>:
              <D.35313>:
            }
            <D.35213>:
            <D.35197>:
            if (alloc == 0B) goto <D.35375>; else goto <D.35376>;
            <D.35375>:
            D.30241 = cfg->mempool;
            ins = mono_mempool_alloc (D.30241, 80);
            ins->data.op[1].const_val = 0;
            D.30457 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.30457;
            ins->prev = 0B;
            D.30458 = ins->prev;
            ins->next = D.30458;
            ins->opcode = 424;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.30459 = ins->sreg3;
            ins->sreg2 = D.30459;
            D.30460 = ins->sreg2;
            ins->sreg1 = D.30460;
            D.30461 = cfg->ip;
            ins->cil_code = D.30461;
            D.30978 = cfg->varinfo;
            D.35218 = iargs[0];
            D.35221 = D.35218->data.op[0].const_val;
            D.35222 = (long unsigned int) D.35221;
            D.35223 = D.35222 * 8;
            D.35224 = D.30978 + D.35223;
            D.35225 = *D.35224;
            D.35233 = D.35225->data.op[1].vtype;
            D.35377 = mono_type_to_regmove (cfg, D.35233);
            D.35378 = (short unsigned int) D.35377;
            ins->opcode = D.35378;
            D.30978 = cfg->varinfo;
            D.35218 = iargs[0];
            D.35221 = D.35218->data.op[0].const_val;
            D.35222 = (long unsigned int) D.35221;
            D.35223 = D.35222 * 8;
            D.35224 = D.30978 + D.35223;
            D.35225 = *D.35224;
            D.35233 = D.35225->data.op[1].vtype;
            type_to_eval_stack_type (cfg, D.35233, ins);
            D.30978 = cfg->varinfo;
            D.35218 = iargs[0];
            D.35221 = D.35218->data.op[0].const_val;
            D.35222 = (long unsigned int) D.35221;
            D.35223 = D.35222 * 8;
            D.35224 = D.30978 + D.35223;
            D.35225 = *D.35224;
            D.35228 = D.35225->klass;
            ins->klass = D.35228;
            D.30978 = cfg->varinfo;
            D.35218 = iargs[0];
            D.35221 = D.35218->data.op[0].const_val;
            D.35222 = (long unsigned int) D.35221;
            D.35223 = D.35222 * 8;
            D.35224 = D.30978 + D.35223;
            D.35225 = *D.35224;
            D.35240 = D.35225->dreg;
            ins->sreg1 = D.35240;
            D.30988 = ins->type;
            D.30989 = (<unnamed type>) D.30988;
            D.35379 = alloc_dreg (cfg, D.30989);
            D.35380 = (int) D.35379;
            ins->dreg = D.35380;
            D.30992 = ins->opcode;
            if (D.30992 == 427) goto <D.35381>; else goto <D.35382>;
            <D.35381>:
            D.30978 = cfg->varinfo;
            D.35218 = iargs[0];
            D.35221 = D.35218->data.op[0].const_val;
            D.35222 = (long unsigned int) D.35221;
            D.35223 = D.35222 * 8;
            D.35224 = D.30978 + D.35223;
            D.35225 = *D.35224;
            D.35233 = D.35225->data.op[1].vtype;
            D.35383 = mono_class_from_mono_type (D.35233);
            ins->klass = D.35383;
            <D.35382>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.35384>; else goto <D.35385>;
            <D.35384>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = ins;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            ins->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            goto <D.35386>;
            <D.35385>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.35386>:
            D.35387 = ins->klass;
            D.35388 = &D.35387->byval_arg;
            type_to_eval_stack_type (cfg, D.35388, ins);
            sp.161 = sp;
            sp = sp.161 + 8;
            *sp.161 = ins;
            goto <D.35390>;
            <D.35376>:
            sp.162 = sp;
            sp = sp.162 + 8;
            *sp.162 = alloc;
            <D.35390>:
            ip = ip + 5;
            inline_costs = inline_costs + 5;
            goto <D.27394>;
          }
        finally
          {
            iargs = {CLOBBER};
            this_ins = {CLOBBER};
          }
      }
      <D.27740>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.35392>; else goto <D.35393>;
      <D.35392>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.35394>; else goto <D.35395>;
      <D.35394>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.35396>; else goto <D.35397>;
      <D.35396>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35397>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35395>:
      D.35398 = mini_get_debug_options ();
      D.35399 = D.35398->break_on_unverified;
      if (D.35399 != 0) goto <D.35400>; else goto unverified;
      <D.35400>:
      raise (5);
      <D.35393>:
      sp = sp + 18446744073709551608;
      D.31664 = ip + 5;
      if (D.31664 > end) goto <D.35401>; else goto <D.35402>;
      <D.35401>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.35403>; else goto <D.35404>;
      <D.35403>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.35405>; else goto <D.35406>;
      <D.35405>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35406>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35404>:
      D.35407 = mini_get_debug_options ();
      D.35408 = D.35407->break_on_unverified;
      if (D.35408 != 0) goto <D.35409>; else goto unverified;
      <D.35409>:
      raise (5);
      <D.35402>:
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31684 = D.31683 << 24;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31685 = D.31683 >> 8;
      D.31686 = D.31685 & 65280;
      D.31687 = D.31684 | D.31686;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31688 = D.31683 << 8;
      D.31689 = D.31688 & 16711680;
      D.31690 = D.31687 | D.31689;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31691 = D.31683 >> 24;
      token = D.31690 | D.31691;
      klass.163 = mini_get_class (method, token, generic_context);
      klass = klass.163;
      klass.144 = klass;
      if (klass.144 == 0B) goto <D.35411>; else goto <D.35413>;
      <D.35413>:
      klass.144 = klass;
      D.34697 = klass.144->exception_type;
      if (D.34697 != 0) goto <D.35411>; else goto <D.35412>;
      <D.35411>:
      klass.144 = klass;
      cfg->exception_ptr = klass.144;
      D.35414 = mini_get_debug_options ();
      D.35415 = D.35414->break_on_unverified;
      if (D.35415 != 0) goto <D.35416>; else goto load_error;
      <D.35416>:
      raise (5);
      <D.35412>:
      D.31240 = *sp;
      D.32922 = D.31240->type;
      if (D.32922 != 6) goto <D.35417>; else goto <D.35418>;
      <D.35417>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.35419>; else goto <D.35420>;
      <D.35419>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.35421>; else goto <D.35422>;
      <D.35421>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35422>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35420>:
      D.35423 = mini_get_debug_options ();
      D.35424 = D.35423->break_on_unverified;
      if (D.35424 != 0) goto <D.35425>; else goto unverified;
      <D.35425>:
      raise (5);
      <D.35418>:
      klass.144 = klass;
      context_used = mini_class_check_context_used (cfg, klass.144);
      if (context_used == 0) goto <D.35428>; else goto <D.35426>;
      <D.35428>:
      klass.144 = klass;
      D.35429 = mini_class_has_reference_variant_generic_argument (cfg, klass.144, context_used);
      if (D.35429 != 0) goto <D.35430>; else goto <D.35426>;
      <D.35430>:
      {
        struct MonoMethod * mono_castclass;
        struct MonoInst * args[3];

        try
          {
            mono_castclass = mono_marshal_get_castclass_with_cache ();
            D.31240 = *sp;
            args[0] = D.31240;
            D.30241 = cfg->mempool;
            D.35431 = mono_mempool_alloc (D.30241, 80);
            args[1] = D.35431;
            D.35432 = args[1];
            D.35432 = args[1];
            D.35432->data.op[1].const_val = 0;
            D.35433 = D.35432->data.op[1].const_val;
            D.35432->data.op[0].const_val = D.35433;
            D.35432 = args[1];
            D.35432 = args[1];
            D.35432->prev = 0B;
            D.35434 = D.35432->prev;
            D.35432->next = D.35434;
            D.35432 = args[1];
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.35436>; else goto <D.35437>;
            <D.35436>:
            iftmp.164 = 732;
            goto <D.35438>;
            <D.35437>:
            iftmp.164 = 363;
            <D.35438>:
            D.35432->opcode = iftmp.164;
            D.35432 = args[1];
            D.35432->flags = 0;
            D.35432 = args[1];
            D.35432->type = 0;
            D.35432 = args[1];
            D.35432->dreg = -1;
            D.35432 = args[1];
            D.35432 = args[1];
            D.35432 = args[1];
            D.35432->sreg3 = -1;
            D.35439 = D.35432->sreg3;
            D.35432->sreg2 = D.35439;
            D.35440 = D.35432->sreg2;
            D.35432->sreg1 = D.35440;
            D.35432 = args[1];
            D.30461 = cfg->ip;
            D.35432->cil_code = D.30461;
            D.35432 = args[1];
            klass.144 = klass;
            D.35432->data.op[0].p = klass.144;
            D.35432 = args[1];
            D.35432->data.op[1].src = 11B;
            D.35432 = args[1];
            D.35432->type = 3;
            D.35432 = args[1];
            D.35441 = alloc_dreg (cfg, 3);
            D.35442 = (int) D.35441;
            D.35432->dreg = D.35442;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.35443>; else goto <D.35444>;
            <D.35443>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.35432 = args[1];
            D.30490->next = D.35432;
            D.35432 = args[1];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.35432->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.35432 = args[1];
            bblock.106->last_ins = D.35432;
            goto <D.35445>;
            <D.35444>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.35432 = args[1];
            bblock.106->last_ins = D.35432;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.35445>:
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.35446>; else goto <D.35447>;
            <D.35446>:
            D.30241 = cfg->mempool;
            D.35448 = mono_mempool_alloc (D.30241, 80);
            args[2] = D.35448;
            D.35449 = args[2];
            D.35449 = args[2];
            D.35449->data.op[1].const_val = 0;
            D.35450 = D.35449->data.op[1].const_val;
            D.35449->data.op[0].const_val = D.35450;
            D.35449 = args[2];
            D.35449 = args[2];
            D.35449->prev = 0B;
            D.35451 = D.35449->prev;
            D.35449->next = D.35451;
            D.35449 = args[2];
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.35453>; else goto <D.35454>;
            <D.35453>:
            iftmp.165 = 732;
            goto <D.35455>;
            <D.35454>:
            iftmp.165 = 363;
            <D.35455>:
            D.35449->opcode = iftmp.165;
            D.35449 = args[2];
            D.35449->flags = 0;
            D.35449 = args[2];
            D.35449->type = 0;
            D.35449 = args[2];
            D.35449->dreg = -1;
            D.35449 = args[2];
            D.35449 = args[2];
            D.35449 = args[2];
            D.35449->sreg3 = -1;
            D.35456 = D.35449->sreg3;
            D.35449->sreg2 = D.35456;
            D.35457 = D.35449->sreg2;
            D.35449->sreg1 = D.35457;
            D.35449 = args[2];
            D.30461 = cfg->ip;
            D.35449->cil_code = D.30461;
            D.35449 = args[2];
            D.35449->data.op[0].p = 0B;
            D.35449 = args[2];
            D.35449->data.op[1].src = 43B;
            D.35449 = args[2];
            D.35449->type = 3;
            D.35449 = args[2];
            D.35458 = alloc_dreg (cfg, 3);
            D.35459 = (int) D.35458;
            D.35449->dreg = D.35459;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.35460>; else goto <D.35461>;
            <D.35460>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.35449 = args[2];
            D.30490->next = D.35449;
            D.35449 = args[2];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.35449->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.35449 = args[2];
            bblock.106->last_ins = D.35449;
            goto <D.35462>;
            <D.35461>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.35449 = args[2];
            bblock.106->last_ins = D.35449;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.35462>:
            goto <D.35463>;
            <D.35447>:
            D.30241 = cfg->mempool;
            D.35464 = mono_mempool_alloc (D.30241, 80);
            args[2] = D.35464;
            D.35449 = args[2];
            D.35449 = args[2];
            D.35449->data.op[1].const_val = 0;
            D.35450 = D.35449->data.op[1].const_val;
            D.35449->data.op[0].const_val = D.35450;
            D.35449 = args[2];
            D.35449 = args[2];
            D.35449->prev = 0B;
            D.35451 = D.35449->prev;
            D.35449->next = D.35451;
            D.35449 = args[2];
            D.35449->opcode = 363;
            D.35449 = args[2];
            D.35449->flags = 0;
            D.35449 = args[2];
            D.35449->type = 0;
            D.35449 = args[2];
            D.35449->dreg = -1;
            D.35449 = args[2];
            D.35449 = args[2];
            D.35449 = args[2];
            D.35449->sreg3 = -1;
            D.35456 = D.35449->sreg3;
            D.35449->sreg2 = D.35456;
            D.35457 = D.35449->sreg2;
            D.35449->sreg1 = D.35457;
            D.35449 = args[2];
            D.30461 = cfg->ip;
            D.35449->cil_code = D.30461;
            D.35449 = args[2];
            D.30267 = cfg->domain;
            D.35465 = mono_domain_alloc0 (D.30267, 8);
            D.35449->data.op[0].p = D.35465;
            D.35449 = args[2];
            D.35449->type = 3;
            D.35449 = args[2];
            D.35466 = alloc_dreg (cfg, 3);
            D.35467 = (int) D.35466;
            D.35449->dreg = D.35467;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.35468>; else goto <D.35469>;
            <D.35468>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.35449 = args[2];
            D.30490->next = D.35449;
            D.35449 = args[2];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.35449->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.35449 = args[2];
            bblock.106->last_ins = D.35449;
            goto <D.35470>;
            <D.35469>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.35449 = args[2];
            bblock.106->last_ins = D.35449;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.35470>:
            <D.35463>:
            klass.144 = klass;
            D.31240 = *sp;
            D.31422 = D.31240->dreg;
            save_cast_details (cfg, klass.144, D.31422, 1, &bblock);
            sp.166 = sp;
            sp = sp.166 + 8;
            D.35472 = mono_emit_method_call (cfg, mono_castclass, &args, 0B);
            *sp.166 = D.35472;
            reset_cast_details (cfg);
            ip = ip + 5;
            inline_costs = inline_costs + 2;
          }
        finally
          {
            args = {CLOBBER};
          }
      }
      goto <D.35427>;
      <D.35426>:
      if (context_used == 0) goto <D.35476>; else goto <D.35473>;
      <D.35476>:
      klass.144 = klass;
      D.35477 = BIT_FIELD_REF <*klass.144, 64, 256>;
      D.35478 = D.35477 & 2199023255552;
      if (D.35478 != 0) goto <D.35474>; else goto <D.35479>;
      <D.35479>:
      klass.144 = klass;
      D.35480 = klass.144->flags;
      D.35481 = D.35480 & 32;
      if (D.35481 != 0) goto <D.35474>; else goto <D.35473>;
      <D.35474>:
      {
        struct MonoMethod * mono_castclass;
        struct MonoInst * iargs[1];
        int costs;

        try
          {
            klass.144 = klass;
            mono_castclass = mono_marshal_get_castclass (klass.144);
            D.31240 = *sp;
            iargs[0] = D.31240;
            klass.144 = klass;
            D.31240 = *sp;
            D.31422 = D.31240->dreg;
            save_cast_details (cfg, klass.144, D.31422, 1, &bblock);
            D.35482 = mono_method_signature (mono_castclass);
            D.30408 = cfg->real_offset;
            costs = inline_method (cfg, mono_castclass, D.35482, &iargs, ip, D.30408, dont_inline, 1);
            reset_cast_details (cfg);
            D.30793 = cfg->exception_type;
            if (D.30793 != 0) goto exception_exit; else goto <D.35483>;
            <D.35483>:
            D.35484 = costs <= 0;
            D.35485 = (long int) D.35484;
            D.35486 = __builtin_expect (D.35485, 0);
            if (D.35486 != 0) goto <D.35487>; else goto <D.35488>;
            <D.35487>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9524, "costs > 0");
            <D.35488>:
            ip = ip + 5;
            D.30408 = cfg->real_offset;
            D.33020 = D.30408 + 5;
            cfg->real_offset = D.33020;
            bblock.106 = cfg->cbb;
            bblock = bblock.106;
            sp.167 = sp;
            sp = sp.167 + 8;
            D.35490 = iargs[0];
            *sp.167 = D.35490;
            inline_costs = inline_costs + costs;
          }
        finally
          {
            iargs = {CLOBBER};
          }
      }
      goto <D.35475>;
      <D.35473>:
      klass.144 = klass;
      D.31240 = *sp;
      ins = handle_castclass (cfg, klass.144, D.31240, context_used);
      D.30793 = cfg->exception_type;
      if (D.30793 != 0) goto exception_exit; else goto <D.35491>;
      <D.35491>:
      bblock.106 = cfg->cbb;
      bblock = bblock.106;
      sp.168 = sp;
      sp = sp.168 + 8;
      *sp.168 = ins;
      ip = ip + 5;
      <D.35475>:
      <D.35427>:
      goto <D.27394>;
      <D.27746>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.35493>; else goto <D.35494>;
      <D.35493>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.35495>; else goto <D.35496>;
      <D.35495>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.35497>; else goto <D.35498>;
      <D.35497>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35498>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35496>:
      D.35499 = mini_get_debug_options ();
      D.35500 = D.35499->break_on_unverified;
      if (D.35500 != 0) goto <D.35501>; else goto unverified;
      <D.35501>:
      raise (5);
      <D.35494>:
      sp = sp + 18446744073709551608;
      D.31664 = ip + 5;
      if (D.31664 > end) goto <D.35502>; else goto <D.35503>;
      <D.35502>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.35504>; else goto <D.35505>;
      <D.35504>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.35506>; else goto <D.35507>;
      <D.35506>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35507>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35505>:
      D.35508 = mini_get_debug_options ();
      D.35509 = D.35508->break_on_unverified;
      if (D.35509 != 0) goto <D.35510>; else goto unverified;
      <D.35510>:
      raise (5);
      <D.35503>:
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31684 = D.31683 << 24;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31685 = D.31683 >> 8;
      D.31686 = D.31685 & 65280;
      D.31687 = D.31684 | D.31686;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31688 = D.31683 << 8;
      D.31689 = D.31688 & 16711680;
      D.31690 = D.31687 | D.31689;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31691 = D.31683 >> 24;
      token = D.31690 | D.31691;
      klass.169 = mini_get_class (method, token, generic_context);
      klass = klass.169;
      klass.144 = klass;
      if (klass.144 == 0B) goto <D.35512>; else goto <D.35514>;
      <D.35514>:
      klass.144 = klass;
      D.34697 = klass.144->exception_type;
      if (D.34697 != 0) goto <D.35512>; else goto <D.35513>;
      <D.35512>:
      klass.144 = klass;
      cfg->exception_ptr = klass.144;
      D.35515 = mini_get_debug_options ();
      D.35516 = D.35515->break_on_unverified;
      if (D.35516 != 0) goto <D.35517>; else goto load_error;
      <D.35517>:
      raise (5);
      <D.35513>:
      D.31240 = *sp;
      D.32922 = D.31240->type;
      if (D.32922 != 6) goto <D.35518>; else goto <D.35519>;
      <D.35518>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.35520>; else goto <D.35521>;
      <D.35520>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.35522>; else goto <D.35523>;
      <D.35522>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35523>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35521>:
      D.35524 = mini_get_debug_options ();
      D.35525 = D.35524->break_on_unverified;
      if (D.35525 != 0) goto <D.35526>; else goto unverified;
      <D.35526>:
      raise (5);
      <D.35519>:
      klass.144 = klass;
      context_used = mini_class_check_context_used (cfg, klass.144);
      if (context_used == 0) goto <D.35529>; else goto <D.35527>;
      <D.35529>:
      klass.144 = klass;
      D.35530 = mini_class_has_reference_variant_generic_argument (cfg, klass.144, context_used);
      if (D.35530 != 0) goto <D.35531>; else goto <D.35527>;
      <D.35531>:
      {
        struct MonoMethod * mono_isinst;
        struct MonoInst * args[3];

        try
          {
            mono_isinst = mono_marshal_get_isinst_with_cache ();
            D.31240 = *sp;
            args[0] = D.31240;
            D.30241 = cfg->mempool;
            D.35532 = mono_mempool_alloc (D.30241, 80);
            args[1] = D.35532;
            D.35533 = args[1];
            D.35533 = args[1];
            D.35533->data.op[1].const_val = 0;
            D.35534 = D.35533->data.op[1].const_val;
            D.35533->data.op[0].const_val = D.35534;
            D.35533 = args[1];
            D.35533 = args[1];
            D.35533->prev = 0B;
            D.35535 = D.35533->prev;
            D.35533->next = D.35535;
            D.35533 = args[1];
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.35537>; else goto <D.35538>;
            <D.35537>:
            iftmp.170 = 732;
            goto <D.35539>;
            <D.35538>:
            iftmp.170 = 363;
            <D.35539>:
            D.35533->opcode = iftmp.170;
            D.35533 = args[1];
            D.35533->flags = 0;
            D.35533 = args[1];
            D.35533->type = 0;
            D.35533 = args[1];
            D.35533->dreg = -1;
            D.35533 = args[1];
            D.35533 = args[1];
            D.35533 = args[1];
            D.35533->sreg3 = -1;
            D.35540 = D.35533->sreg3;
            D.35533->sreg2 = D.35540;
            D.35541 = D.35533->sreg2;
            D.35533->sreg1 = D.35541;
            D.35533 = args[1];
            D.30461 = cfg->ip;
            D.35533->cil_code = D.30461;
            D.35533 = args[1];
            klass.144 = klass;
            D.35533->data.op[0].p = klass.144;
            D.35533 = args[1];
            D.35533->data.op[1].src = 11B;
            D.35533 = args[1];
            D.35533->type = 3;
            D.35533 = args[1];
            D.35542 = alloc_dreg (cfg, 3);
            D.35543 = (int) D.35542;
            D.35533->dreg = D.35543;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.35544>; else goto <D.35545>;
            <D.35544>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.35533 = args[1];
            D.30490->next = D.35533;
            D.35533 = args[1];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.35533->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.35533 = args[1];
            bblock.106->last_ins = D.35533;
            goto <D.35546>;
            <D.35545>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.35533 = args[1];
            bblock.106->last_ins = D.35533;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.35546>:
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.35547>; else goto <D.35548>;
            <D.35547>:
            D.30241 = cfg->mempool;
            D.35549 = mono_mempool_alloc (D.30241, 80);
            args[2] = D.35549;
            D.35550 = args[2];
            D.35550 = args[2];
            D.35550->data.op[1].const_val = 0;
            D.35551 = D.35550->data.op[1].const_val;
            D.35550->data.op[0].const_val = D.35551;
            D.35550 = args[2];
            D.35550 = args[2];
            D.35550->prev = 0B;
            D.35552 = D.35550->prev;
            D.35550->next = D.35552;
            D.35550 = args[2];
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.35554>; else goto <D.35555>;
            <D.35554>:
            iftmp.171 = 732;
            goto <D.35556>;
            <D.35555>:
            iftmp.171 = 363;
            <D.35556>:
            D.35550->opcode = iftmp.171;
            D.35550 = args[2];
            D.35550->flags = 0;
            D.35550 = args[2];
            D.35550->type = 0;
            D.35550 = args[2];
            D.35550->dreg = -1;
            D.35550 = args[2];
            D.35550 = args[2];
            D.35550 = args[2];
            D.35550->sreg3 = -1;
            D.35557 = D.35550->sreg3;
            D.35550->sreg2 = D.35557;
            D.35558 = D.35550->sreg2;
            D.35550->sreg1 = D.35558;
            D.35550 = args[2];
            D.30461 = cfg->ip;
            D.35550->cil_code = D.30461;
            D.35550 = args[2];
            D.35550->data.op[0].p = 0B;
            D.35550 = args[2];
            D.35550->data.op[1].src = 43B;
            D.35550 = args[2];
            D.35550->type = 3;
            D.35550 = args[2];
            D.35559 = alloc_dreg (cfg, 3);
            D.35560 = (int) D.35559;
            D.35550->dreg = D.35560;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.35561>; else goto <D.35562>;
            <D.35561>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.35550 = args[2];
            D.30490->next = D.35550;
            D.35550 = args[2];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.35550->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.35550 = args[2];
            bblock.106->last_ins = D.35550;
            goto <D.35563>;
            <D.35562>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.35550 = args[2];
            bblock.106->last_ins = D.35550;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.35563>:
            goto <D.35564>;
            <D.35548>:
            D.30241 = cfg->mempool;
            D.35565 = mono_mempool_alloc (D.30241, 80);
            args[2] = D.35565;
            D.35550 = args[2];
            D.35550 = args[2];
            D.35550->data.op[1].const_val = 0;
            D.35551 = D.35550->data.op[1].const_val;
            D.35550->data.op[0].const_val = D.35551;
            D.35550 = args[2];
            D.35550 = args[2];
            D.35550->prev = 0B;
            D.35552 = D.35550->prev;
            D.35550->next = D.35552;
            D.35550 = args[2];
            D.35550->opcode = 363;
            D.35550 = args[2];
            D.35550->flags = 0;
            D.35550 = args[2];
            D.35550->type = 0;
            D.35550 = args[2];
            D.35550->dreg = -1;
            D.35550 = args[2];
            D.35550 = args[2];
            D.35550 = args[2];
            D.35550->sreg3 = -1;
            D.35557 = D.35550->sreg3;
            D.35550->sreg2 = D.35557;
            D.35558 = D.35550->sreg2;
            D.35550->sreg1 = D.35558;
            D.35550 = args[2];
            D.30461 = cfg->ip;
            D.35550->cil_code = D.30461;
            D.35550 = args[2];
            D.30267 = cfg->domain;
            D.35566 = mono_domain_alloc0 (D.30267, 8);
            D.35550->data.op[0].p = D.35566;
            D.35550 = args[2];
            D.35550->type = 3;
            D.35550 = args[2];
            D.35567 = alloc_dreg (cfg, 3);
            D.35568 = (int) D.35567;
            D.35550->dreg = D.35568;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.35569>; else goto <D.35570>;
            <D.35569>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.35550 = args[2];
            D.30490->next = D.35550;
            D.35550 = args[2];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.35550->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.35550 = args[2];
            bblock.106->last_ins = D.35550;
            goto <D.35571>;
            <D.35570>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.35550 = args[2];
            bblock.106->last_ins = D.35550;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.35571>:
            <D.35564>:
            sp.172 = sp;
            sp = sp.172 + 8;
            D.35573 = mono_emit_method_call (cfg, mono_isinst, &args, 0B);
            *sp.172 = D.35573;
            ip = ip + 5;
            inline_costs = inline_costs + 2;
          }
        finally
          {
            args = {CLOBBER};
          }
      }
      goto <D.35528>;
      <D.35527>:
      if (context_used == 0) goto <D.35577>; else goto <D.35574>;
      <D.35577>:
      klass.144 = klass;
      D.35477 = BIT_FIELD_REF <*klass.144, 64, 256>;
      D.35478 = D.35477 & 2199023255552;
      if (D.35478 != 0) goto <D.35575>; else goto <D.35578>;
      <D.35578>:
      klass.144 = klass;
      D.35480 = klass.144->flags;
      D.35481 = D.35480 & 32;
      if (D.35481 != 0) goto <D.35575>; else goto <D.35574>;
      <D.35575>:
      {
        struct MonoMethod * mono_isinst;
        struct MonoInst * iargs[1];
        int costs;

        try
          {
            klass.144 = klass;
            mono_isinst = mono_marshal_get_isinst (klass.144);
            D.31240 = *sp;
            iargs[0] = D.31240;
            D.35579 = mono_method_signature (mono_isinst);
            D.30408 = cfg->real_offset;
            costs = inline_method (cfg, mono_isinst, D.35579, &iargs, ip, D.30408, dont_inline, 1);
            D.30793 = cfg->exception_type;
            if (D.30793 != 0) goto exception_exit; else goto <D.35580>;
            <D.35580>:
            D.35581 = costs <= 0;
            D.35582 = (long int) D.35581;
            D.35583 = __builtin_expect (D.35582, 0);
            if (D.35583 != 0) goto <D.35584>; else goto <D.35585>;
            <D.35584>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9584, "costs > 0");
            <D.35585>:
            ip = ip + 5;
            D.30408 = cfg->real_offset;
            D.33020 = D.30408 + 5;
            cfg->real_offset = D.33020;
            bblock.106 = cfg->cbb;
            bblock = bblock.106;
            sp.173 = sp;
            sp = sp.173 + 8;
            D.35587 = iargs[0];
            *sp.173 = D.35587;
            inline_costs = inline_costs + costs;
          }
        finally
          {
            iargs = {CLOBBER};
          }
      }
      goto <D.35576>;
      <D.35574>:
      klass.144 = klass;
      D.31240 = *sp;
      ins = handle_isinst (cfg, klass.144, D.31240, context_used);
      D.30793 = cfg->exception_type;
      if (D.30793 != 0) goto exception_exit; else goto <D.35588>;
      <D.35588>:
      bblock.106 = cfg->cbb;
      bblock = bblock.106;
      sp.174 = sp;
      sp = sp.174 + 8;
      *sp.174 = ins;
      ip = ip + 5;
      <D.35576>:
      <D.35528>:
      goto <D.27394>;
      <D.27752>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.35590>; else goto <D.35591>;
      <D.35590>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.35592>; else goto <D.35593>;
      <D.35592>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.35594>; else goto <D.35595>;
      <D.35594>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35595>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35593>:
      D.35596 = mini_get_debug_options ();
      D.35597 = D.35596->break_on_unverified;
      if (D.35597 != 0) goto <D.35598>; else goto unverified;
      <D.35598>:
      raise (5);
      <D.35591>:
      sp = sp + 18446744073709551608;
      D.31664 = ip + 5;
      if (D.31664 > end) goto <D.35599>; else goto <D.35600>;
      <D.35599>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.35601>; else goto <D.35602>;
      <D.35601>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.35603>; else goto <D.35604>;
      <D.35603>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35604>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35602>:
      D.35605 = mini_get_debug_options ();
      D.35606 = D.35605->break_on_unverified;
      if (D.35606 != 0) goto <D.35607>; else goto unverified;
      <D.35607>:
      raise (5);
      <D.35600>:
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31684 = D.31683 << 24;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31685 = D.31683 >> 8;
      D.31686 = D.31685 & 65280;
      D.31687 = D.31684 | D.31686;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31688 = D.31683 << 8;
      D.31689 = D.31688 & 16711680;
      D.31690 = D.31687 | D.31689;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31691 = D.31683 >> 24;
      token = D.31690 | D.31691;
      klass.175 = mini_get_class (method, token, generic_context);
      klass = klass.175;
      klass.144 = klass;
      if (klass.144 == 0B) goto <D.35609>; else goto <D.35611>;
      <D.35611>:
      klass.144 = klass;
      D.34697 = klass.144->exception_type;
      if (D.34697 != 0) goto <D.35609>; else goto <D.35610>;
      <D.35609>:
      klass.144 = klass;
      cfg->exception_ptr = klass.144;
      D.35612 = mini_get_debug_options ();
      D.35613 = D.35612->break_on_unverified;
      if (D.35613 != 0) goto <D.35614>; else goto load_error;
      <D.35614>:
      raise (5);
      <D.35610>:
      klass.144 = klass;
      mono_save_token_info (cfg, image, token, klass.144);
      klass.144 = klass;
      context_used = mini_class_check_context_used (cfg, klass.144);
      klass.144 = klass;
      D.35615 = mini_is_gsharedvt_klass (cfg, klass.144);
      if (D.35615 != 0) goto <D.35616>; else goto <D.35617>;
      <D.35616>:
      klass.144 = klass;
      D.31240 = *sp;
      D.35618 = handle_unbox_gsharedvt (cfg, klass.144, D.31240, &bblock);
      *sp = D.35618;
      sp = sp + 8;
      ip = ip + 5;
      inline_costs = inline_costs + 2;
      goto <D.27394>;
      <D.35617>:
      klass.144 = klass;
      D.35619 = generic_class_is_reference_type (cfg, klass.144);
      if (D.35619 != 0) goto <D.35620>; else goto <D.35621>;
      <D.35620>:
      if (context_used == 0) goto <D.35624>; else goto <D.35622>;
      <D.35624>:
      klass.144 = klass;
      D.35625 = mini_class_has_reference_variant_generic_argument (cfg, klass.144, context_used);
      if (D.35625 != 0) goto <D.35626>; else goto <D.35622>;
      <D.35626>:
      {
        struct MonoMethod * mono_castclass;
        struct MonoInst * args[3];

        try
          {
            mono_castclass = mono_marshal_get_castclass_with_cache ();
            D.31240 = *sp;
            args[0] = D.31240;
            D.30241 = cfg->mempool;
            D.35627 = mono_mempool_alloc (D.30241, 80);
            args[1] = D.35627;
            D.35628 = args[1];
            D.35628 = args[1];
            D.35628->data.op[1].const_val = 0;
            D.35629 = D.35628->data.op[1].const_val;
            D.35628->data.op[0].const_val = D.35629;
            D.35628 = args[1];
            D.35628 = args[1];
            D.35628->prev = 0B;
            D.35630 = D.35628->prev;
            D.35628->next = D.35630;
            D.35628 = args[1];
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.35632>; else goto <D.35633>;
            <D.35632>:
            iftmp.176 = 732;
            goto <D.35634>;
            <D.35633>:
            iftmp.176 = 363;
            <D.35634>:
            D.35628->opcode = iftmp.176;
            D.35628 = args[1];
            D.35628->flags = 0;
            D.35628 = args[1];
            D.35628->type = 0;
            D.35628 = args[1];
            D.35628->dreg = -1;
            D.35628 = args[1];
            D.35628 = args[1];
            D.35628 = args[1];
            D.35628->sreg3 = -1;
            D.35635 = D.35628->sreg3;
            D.35628->sreg2 = D.35635;
            D.35636 = D.35628->sreg2;
            D.35628->sreg1 = D.35636;
            D.35628 = args[1];
            D.30461 = cfg->ip;
            D.35628->cil_code = D.30461;
            D.35628 = args[1];
            klass.144 = klass;
            D.35628->data.op[0].p = klass.144;
            D.35628 = args[1];
            D.35628->data.op[1].src = 11B;
            D.35628 = args[1];
            D.35628->type = 3;
            D.35628 = args[1];
            D.35637 = alloc_dreg (cfg, 3);
            D.35638 = (int) D.35637;
            D.35628->dreg = D.35638;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.35639>; else goto <D.35640>;
            <D.35639>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.35628 = args[1];
            D.30490->next = D.35628;
            D.35628 = args[1];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.35628->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.35628 = args[1];
            bblock.106->last_ins = D.35628;
            goto <D.35641>;
            <D.35640>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.35628 = args[1];
            bblock.106->last_ins = D.35628;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.35641>:
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.35642>; else goto <D.35643>;
            <D.35642>:
            D.30241 = cfg->mempool;
            D.35644 = mono_mempool_alloc (D.30241, 80);
            args[2] = D.35644;
            D.35645 = args[2];
            D.35645 = args[2];
            D.35645->data.op[1].const_val = 0;
            D.35646 = D.35645->data.op[1].const_val;
            D.35645->data.op[0].const_val = D.35646;
            D.35645 = args[2];
            D.35645 = args[2];
            D.35645->prev = 0B;
            D.35647 = D.35645->prev;
            D.35645->next = D.35647;
            D.35645 = args[2];
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.35649>; else goto <D.35650>;
            <D.35649>:
            iftmp.177 = 732;
            goto <D.35651>;
            <D.35650>:
            iftmp.177 = 363;
            <D.35651>:
            D.35645->opcode = iftmp.177;
            D.35645 = args[2];
            D.35645->flags = 0;
            D.35645 = args[2];
            D.35645->type = 0;
            D.35645 = args[2];
            D.35645->dreg = -1;
            D.35645 = args[2];
            D.35645 = args[2];
            D.35645 = args[2];
            D.35645->sreg3 = -1;
            D.35652 = D.35645->sreg3;
            D.35645->sreg2 = D.35652;
            D.35653 = D.35645->sreg2;
            D.35645->sreg1 = D.35653;
            D.35645 = args[2];
            D.30461 = cfg->ip;
            D.35645->cil_code = D.30461;
            D.35645 = args[2];
            D.35645->data.op[0].p = 0B;
            D.35645 = args[2];
            D.35645->data.op[1].src = 43B;
            D.35645 = args[2];
            D.35645->type = 3;
            D.35645 = args[2];
            D.35654 = alloc_dreg (cfg, 3);
            D.35655 = (int) D.35654;
            D.35645->dreg = D.35655;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.35656>; else goto <D.35657>;
            <D.35656>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.35645 = args[2];
            D.30490->next = D.35645;
            D.35645 = args[2];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.35645->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.35645 = args[2];
            bblock.106->last_ins = D.35645;
            goto <D.35658>;
            <D.35657>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.35645 = args[2];
            bblock.106->last_ins = D.35645;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.35658>:
            goto <D.35659>;
            <D.35643>:
            D.30241 = cfg->mempool;
            D.35660 = mono_mempool_alloc (D.30241, 80);
            args[2] = D.35660;
            D.35645 = args[2];
            D.35645 = args[2];
            D.35645->data.op[1].const_val = 0;
            D.35646 = D.35645->data.op[1].const_val;
            D.35645->data.op[0].const_val = D.35646;
            D.35645 = args[2];
            D.35645 = args[2];
            D.35645->prev = 0B;
            D.35647 = D.35645->prev;
            D.35645->next = D.35647;
            D.35645 = args[2];
            D.35645->opcode = 363;
            D.35645 = args[2];
            D.35645->flags = 0;
            D.35645 = args[2];
            D.35645->type = 0;
            D.35645 = args[2];
            D.35645->dreg = -1;
            D.35645 = args[2];
            D.35645 = args[2];
            D.35645 = args[2];
            D.35645->sreg3 = -1;
            D.35652 = D.35645->sreg3;
            D.35645->sreg2 = D.35652;
            D.35653 = D.35645->sreg2;
            D.35645->sreg1 = D.35653;
            D.35645 = args[2];
            D.30461 = cfg->ip;
            D.35645->cil_code = D.30461;
            D.35645 = args[2];
            D.30267 = cfg->domain;
            D.35661 = mono_domain_alloc0 (D.30267, 8);
            D.35645->data.op[0].p = D.35661;
            D.35645 = args[2];
            D.35645->type = 3;
            D.35645 = args[2];
            D.35662 = alloc_dreg (cfg, 3);
            D.35663 = (int) D.35662;
            D.35645->dreg = D.35663;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.35664>; else goto <D.35665>;
            <D.35664>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.35645 = args[2];
            D.30490->next = D.35645;
            D.35645 = args[2];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.35645->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.35645 = args[2];
            bblock.106->last_ins = D.35645;
            goto <D.35666>;
            <D.35665>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.35645 = args[2];
            bblock.106->last_ins = D.35645;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.35666>:
            <D.35659>:
            sp.178 = sp;
            sp = sp.178 + 8;
            D.35668 = mono_emit_method_call (cfg, mono_castclass, &args, 0B);
            *sp.178 = D.35668;
            ip = ip + 5;
            inline_costs = inline_costs + 2;
          }
        finally
          {
            args = {CLOBBER};
          }
      }
      goto <D.35623>;
      <D.35622>:
      if (context_used == 0) goto <D.35672>; else goto <D.35669>;
      <D.35672>:
      klass.144 = klass;
      D.35477 = BIT_FIELD_REF <*klass.144, 64, 256>;
      D.35478 = D.35477 & 2199023255552;
      if (D.35478 != 0) goto <D.35670>; else goto <D.35673>;
      <D.35673>:
      klass.144 = klass;
      D.35480 = klass.144->flags;
      D.35481 = D.35480 & 32;
      if (D.35481 != 0) goto <D.35670>; else goto <D.35669>;
      <D.35670>:
      {
        struct MonoMethod * mono_castclass;
        struct MonoInst * iargs[1];
        int costs;

        try
          {
            klass.144 = klass;
            mono_castclass = mono_marshal_get_castclass (klass.144);
            D.31240 = *sp;
            iargs[0] = D.31240;
            D.35674 = mono_method_signature (mono_castclass);
            D.30408 = cfg->real_offset;
            costs = inline_method (cfg, mono_castclass, D.35674, &iargs, ip, D.30408, dont_inline, 1);
            D.30793 = cfg->exception_type;
            if (D.30793 != 0) goto exception_exit; else goto <D.35675>;
            <D.35675>:
            D.35676 = costs <= 0;
            D.35677 = (long int) D.35676;
            D.35678 = __builtin_expect (D.35677, 0);
            if (D.35678 != 0) goto <D.35679>; else goto <D.35680>;
            <D.35679>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9658, "costs > 0");
            <D.35680>:
            ip = ip + 5;
            D.30408 = cfg->real_offset;
            D.33020 = D.30408 + 5;
            cfg->real_offset = D.33020;
            bblock.106 = cfg->cbb;
            bblock = bblock.106;
            sp.179 = sp;
            sp = sp.179 + 8;
            D.35682 = iargs[0];
            *sp.179 = D.35682;
            inline_costs = inline_costs + costs;
          }
        finally
          {
            iargs = {CLOBBER};
          }
      }
      goto <D.35671>;
      <D.35669>:
      klass.144 = klass;
      D.31240 = *sp;
      ins = handle_castclass (cfg, klass.144, D.31240, context_used);
      D.30793 = cfg->exception_type;
      if (D.30793 != 0) goto exception_exit; else goto <D.35683>;
      <D.35683>:
      bblock.106 = cfg->cbb;
      bblock = bblock.106;
      sp.180 = sp;
      sp = sp.180 + 8;
      *sp.180 = ins;
      ip = ip + 5;
      <D.35671>:
      <D.35623>:
      goto <D.27394>;
      <D.35621>:
      klass.144 = klass;
      D.35685 = mono_class_is_nullable (klass.144);
      if (D.35685 != 0) goto <D.35686>; else goto <D.35687>;
      <D.35686>:
      D.31240 = *sp;
      klass.144 = klass;
      ins = handle_unbox_nullable (cfg, D.31240, klass.144, context_used);
      sp.181 = sp;
      sp = sp.181 + 8;
      *sp.181 = ins;
      ip = ip + 5;
      goto <D.27394>;
      <D.35687>:
      klass.144 = klass;
      ins = handle_unbox (cfg, klass.144, sp, context_used);
      *sp = ins;
      ip = ip + 5;
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      klass.144 = klass;
      D.34771 = &klass.144->byval_arg;
      D.35689 = mono_type_to_load_membase (cfg, D.34771);
      D.35690 = (short unsigned int) D.35689;
      ins->opcode = D.35690;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      ins->dreg = 0;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      ins->data.op[0].const_val = 0;
      ins->type = 1;
      klass.144 = klass;
      D.34771 = &klass.144->byval_arg;
      type_to_eval_stack_type (cfg, D.34771, ins);
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.35691 = alloc_dreg (cfg, D.30989);
      D.35692 = (int) D.35691;
      ins->dreg = D.35692;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.35693>; else goto <D.35694>;
      <D.35693>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.35695>;
      <D.35694>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.35695>:
      sp.182 = sp;
      sp = sp.182 + 8;
      *sp.182 = ins;
      inline_costs = inline_costs + 2;
      goto <D.27394>;
      <D.27758>:
      {
        struct MonoInst * val;

        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        if (D.31013 <= 7) goto <D.35697>; else goto <D.35698>;
        <D.35697>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.35699>; else goto <D.35700>;
        <D.35699>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.35701>; else goto <D.35702>;
        <D.35701>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.35702>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.35700>:
        D.35703 = mini_get_debug_options ();
        D.35704 = D.35703->break_on_unverified;
        if (D.35704 != 0) goto <D.35705>; else goto unverified;
        <D.35705>:
        raise (5);
        <D.35698>:
        sp = sp + 18446744073709551608;
        val = *sp;
        D.31664 = ip + 5;
        if (D.31664 > end) goto <D.35706>; else goto <D.35707>;
        <D.35706>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.35708>; else goto <D.35709>;
        <D.35708>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.35710>; else goto <D.35711>;
        <D.35710>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.35711>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.35709>:
        D.35712 = mini_get_debug_options ();
        D.35713 = D.35712->break_on_unverified;
        if (D.35713 != 0) goto <D.35714>; else goto unverified;
        <D.35714>:
        raise (5);
        <D.35707>:
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31684 = D.31683 << 24;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31685 = D.31683 >> 8;
        D.31686 = D.31685 & 65280;
        D.31687 = D.31684 | D.31686;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31688 = D.31683 << 8;
        D.31689 = D.31688 & 16711680;
        D.31690 = D.31687 | D.31689;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31691 = D.31683 >> 24;
        token = D.31690 | D.31691;
        klass.183 = mini_get_class (method, token, generic_context);
        klass = klass.183;
        klass.144 = klass;
        if (klass.144 == 0B) goto <D.35716>; else goto <D.35718>;
        <D.35718>:
        klass.144 = klass;
        D.34697 = klass.144->exception_type;
        if (D.34697 != 0) goto <D.35716>; else goto <D.35717>;
        <D.35716>:
        klass.144 = klass;
        cfg->exception_ptr = klass.144;
        D.35719 = mini_get_debug_options ();
        D.35720 = D.35719->break_on_unverified;
        if (D.35720 != 0) goto <D.35721>; else goto load_error;
        <D.35721>:
        raise (5);
        <D.35717>:
        klass.144 = klass;
        mono_save_token_info (cfg, image, token, klass.144);
        klass.144 = klass;
        context_used = mini_class_check_context_used (cfg, klass.144);
        klass.144 = klass;
        D.35722 = generic_class_is_reference_type (cfg, klass.144);
        if (D.35722 != 0) goto <D.35723>; else goto <D.35724>;
        <D.35723>:
        sp.184 = sp;
        sp = sp.184 + 8;
        *sp.184 = val;
        ip = ip + 5;
        goto <D.27394>;
        <D.35724>:
        D.35726 = mono_defaults.void_class;
        klass.144 = klass;
        if (D.35726 == klass.144) goto <D.35727>; else goto <D.35728>;
        <D.35727>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.35729>; else goto <D.35730>;
        <D.35729>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.35731>; else goto <D.35732>;
        <D.35731>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.35732>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.35730>:
        D.35733 = mini_get_debug_options ();
        D.35734 = D.35733->break_on_unverified;
        if (D.35734 != 0) goto <D.35735>; else goto unverified;
        <D.35735>:
        raise (5);
        <D.35728>:
        klass.144 = klass;
        D.34771 = &klass.144->byval_arg;
        D.31240 = *sp;
        D.35736 = target_type_is_incompatible (cfg, D.34771, D.31240);
        if (D.35736 != 0) goto <D.35737>; else goto <D.35738>;
        <D.35737>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.35739>; else goto <D.35740>;
        <D.35739>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.35741>; else goto <D.35742>;
        <D.35741>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.35742>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.35740>:
        D.35743 = mini_get_debug_options ();
        D.35744 = D.35743->break_on_unverified;
        if (D.35744 != 0) goto <D.35745>; else goto unverified;
        <D.35745>:
        raise (5);
        <D.35738>:
        klass.144 = klass;
        D.35748 = mono_class_is_nullable (klass.144);
        if (D.35748 == 0) goto <D.35749>; else goto <D.35750>;
        <D.35749>:
        D.31664 = ip + 5;
        if (D.31664 < end) goto <D.35751>; else goto <D.35752>;
        <D.35751>:
        bblock.64 = bblock;
        D.31664 = ip + 5;
        D.35753 = ip_in_bb (cfg, bblock.64, D.31664);
        if (D.35753 != 0) goto <D.35754>; else goto <D.35755>;
        <D.35754>:
        D.31664 = ip + 5;
        D.32220 = *D.31664;
        if (D.32220 == 58) goto <D.35746>; else goto <D.35756>;
        <D.35756>:
        D.31664 = ip + 5;
        D.32220 = *D.31664;
        if (D.32220 == 45) goto <D.35746>; else goto <D.35757>;
        <D.35757>:
        D.31664 = ip + 5;
        D.32220 = *D.31664;
        if (D.32220 == 57) goto <D.35746>; else goto <D.35758>;
        <D.35758>:
        D.31664 = ip + 5;
        D.32220 = *D.31664;
        if (D.32220 == 44) goto <D.35746>; else goto <D.35747>;
        <D.35746>:
        {
          gboolean is_true;
          int dreg;
          struct MonoBasicBlock * true_bb;
          struct MonoBasicBlock * false_bb;

          D.31664 = ip + 5;
          D.32220 = *D.31664;
          if (D.32220 == 58) goto <D.35760>; else goto <D.35763>;
          <D.35763>:
          D.31664 = ip + 5;
          D.32220 = *D.31664;
          if (D.32220 == 45) goto <D.35760>; else goto <D.35761>;
          <D.35760>:
          iftmp.185 = 1;
          goto <D.35762>;
          <D.35761>:
          iftmp.185 = 0;
          <D.35762>:
          is_true = iftmp.185;
          ip = ip + 5;
          D.30322 = cfg->verbose_level;
          if (D.30322 > 3) goto <D.35764>; else goto <D.35765>;
          <D.35764>:
          bblock.64 = bblock;
          D.31119 = bblock.64->block_num;
          sp.71 = (long int) sp;
          stack_start.72 = (long int) stack_start;
          D.31013 = sp.71 - stack_start.72;
          D.31014 = D.31013 /[ex] 8;
          D.31015 = (int) D.31014;
          D.35766 = mono_disasm_code_one (0B, method, ip, 0B);
          printf ("converting (in B%d: stack: %d) %s", D.31119, D.31015, D.35766);
          printf ("<box+brtrue opt>\n");
          <D.35765>:
          D.31121 = *ip;
          D.31122 = (int) D.31121;
          switch (D.31122) <default: <D.27769>, case 44: <D.27765>, case 45: <D.27764>, case 57: <D.27768>, case 58: <D.27767>>
          <D.27764>:
          <D.27765>:
          D.31251 = ip + 2;
          if (D.31251 > end) goto <D.35767>; else goto <D.35768>;
          <D.35767>:
          D.30389 = cfg->gsharedvt;
          if (D.30389 != 0) goto <D.35769>; else goto <D.35770>;
          <D.35769>:
          D.30322 = cfg->verbose_level;
          if (D.30322 > 2) goto <D.35771>; else goto <D.35772>;
          <D.35771>:
          printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
          <D.35772>:
          mono_cfg_set_exception (cfg, 11);
          goto exception_exit;
          <D.35770>:
          D.35773 = mini_get_debug_options ();
          D.35774 = D.35773->break_on_unverified;
          if (D.35774 != 0) goto <D.35775>; else goto unverified;
          <D.35775>:
          raise (5);
          <D.35768>:
          ip = ip + 1;
          D.31121 = *ip;
          D.33620 = (signed char) D.31121;
          D.33621 = (sizetype) D.33620;
          D.33622 = D.33621 + 1;
          target = ip + D.33622;
          ip = ip + 1;
          goto <D.27766>;
          <D.27767>:
          <D.27768>:
          D.31664 = ip + 5;
          if (D.31664 > end) goto <D.35776>; else goto <D.35777>;
          <D.35776>:
          D.30389 = cfg->gsharedvt;
          if (D.30389 != 0) goto <D.35778>; else goto <D.35779>;
          <D.35778>:
          D.30322 = cfg->verbose_level;
          if (D.30322 > 2) goto <D.35780>; else goto <D.35781>;
          <D.35780>:
          printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
          <D.35781>:
          mono_cfg_set_exception (cfg, 11);
          goto exception_exit;
          <D.35779>:
          D.35782 = mini_get_debug_options ();
          D.35783 = D.35782->break_on_unverified;
          if (D.35783 != 0) goto <D.35784>; else goto unverified;
          <D.35784>:
          raise (5);
          <D.35777>:
          ip = ip + 1;
          D.31797 = MEM[(const guint32 *)ip];
          D.31798 = D.31797 << 24;
          D.31797 = MEM[(const guint32 *)ip];
          D.31799 = D.31797 >> 8;
          D.31800 = D.31799 & 65280;
          D.31801 = D.31798 | D.31800;
          D.31797 = MEM[(const guint32 *)ip];
          D.31802 = D.31797 << 8;
          D.31803 = D.31802 & 16711680;
          D.31804 = D.31801 | D.31803;
          D.31797 = MEM[(const guint32 *)ip];
          D.31805 = D.31797 >> 24;
          D.31806 = D.31804 | D.31805;
          D.33761 = (int) D.31806;
          D.33762 = (sizetype) D.33761;
          D.33763 = D.33762 + 4;
          target = ip + D.33763;
          ip = ip + 4;
          goto <D.27766>;
          <D.27769>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 9757);
          <D.27766>:
          D.30372 = cfg->cil_offset_to_bb;
          target.123 = (long int) target;
          D.30377 = cfg->cil_start;
          D.30378 = (long int) D.30377;
          D.33624 = target.123 - D.30378;
          D.33625 = (long unsigned int) D.33624;
          D.33626 = D.33625 * 8;
          D.33627 = D.30372 + D.33626;
          true_bb = *D.33627;
          if (true_bb == 0B) goto <D.35785>; else goto <D.35786>;
          <D.35785>:
          if (target >= end) goto <D.35787>; else goto <D.35789>;
          <D.35789>:
          D.30388 = header->code;
          if (D.30388 > target) goto <D.35787>; else goto <D.35788>;
          <D.35787>:
          D.30389 = cfg->gsharedvt;
          if (D.30389 != 0) goto <D.35790>; else goto <D.35791>;
          <D.35790>:
          D.30322 = cfg->verbose_level;
          if (D.30322 > 2) goto <D.35792>; else goto <D.35793>;
          <D.35792>:
          printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
          <D.35793>:
          mono_cfg_set_exception (cfg, 11);
          goto exception_exit;
          <D.35791>:
          D.35794 = mini_get_debug_options ();
          D.35795 = D.35794->break_on_unverified;
          if (D.35795 != 0) goto <D.35796>; else goto unverified;
          <D.35796>:
          raise (5);
          <D.35788>:
          D.30241 = cfg->mempool;
          true_bb = mono_mempool_alloc0 (D.30241, 296);
          D.30349 = cfg->num_bblocks;
          D.35797 = D.30349;
          D.35798 = D.35797 + 1;
          cfg->num_bblocks = D.35798;
          D.35799 = (int) D.35797;
          true_bb->block_num = D.35799;
          true_bb->cil_code = target;
          D.35800 = true_bb->cil_code;
          if (D.35800 != 0B) goto <D.35801>; else goto <D.35802>;
          <D.35801>:
          D.30372 = cfg->cil_offset_to_bb;
          D.35800 = true_bb->cil_code;
          D.35803 = (long int) D.35800;
          D.30377 = cfg->cil_start;
          D.30378 = (long int) D.30377;
          D.35804 = D.35803 - D.30378;
          D.35805 = (long unsigned int) D.35804;
          D.35806 = D.35805 * 8;
          D.35807 = D.30372 + D.35806;
          *D.35807 = true_bb;
          <D.35802>:
          D.30408 = cfg->real_offset;
          true_bb->real_offset = D.30408;
          <D.35786>:
          D.30372 = cfg->cil_offset_to_bb;
          ip.69 = (long int) ip;
          D.30377 = cfg->cil_start;
          D.30378 = (long int) D.30377;
          D.30949 = ip.69 - D.30378;
          D.30950 = (long unsigned int) D.30949;
          D.30951 = D.30950 * 8;
          D.30952 = D.30372 + D.30951;
          false_bb = *D.30952;
          if (false_bb == 0B) goto <D.35808>; else goto <D.35809>;
          <D.35808>:
          if (ip >= end) goto <D.35810>; else goto <D.35812>;
          <D.35812>:
          D.30388 = header->code;
          if (D.30388 > ip) goto <D.35810>; else goto <D.35811>;
          <D.35810>:
          D.30389 = cfg->gsharedvt;
          if (D.30389 != 0) goto <D.35813>; else goto <D.35814>;
          <D.35813>:
          D.30322 = cfg->verbose_level;
          if (D.30322 > 2) goto <D.35815>; else goto <D.35816>;
          <D.35815>:
          printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
          <D.35816>:
          mono_cfg_set_exception (cfg, 11);
          goto exception_exit;
          <D.35814>:
          D.35817 = mini_get_debug_options ();
          D.35818 = D.35817->break_on_unverified;
          if (D.35818 != 0) goto <D.35819>; else goto unverified;
          <D.35819>:
          raise (5);
          <D.35811>:
          D.30241 = cfg->mempool;
          false_bb = mono_mempool_alloc0 (D.30241, 296);
          D.30349 = cfg->num_bblocks;
          D.35820 = D.30349;
          D.35821 = D.35820 + 1;
          cfg->num_bblocks = D.35821;
          D.35822 = (int) D.35820;
          false_bb->block_num = D.35822;
          false_bb->cil_code = ip;
          D.35823 = false_bb->cil_code;
          if (D.35823 != 0B) goto <D.35824>; else goto <D.35825>;
          <D.35824>:
          D.30372 = cfg->cil_offset_to_bb;
          D.35823 = false_bb->cil_code;
          D.35826 = (long int) D.35823;
          D.30377 = cfg->cil_start;
          D.30378 = (long int) D.30377;
          D.35827 = D.35826 - D.30378;
          D.35828 = (long unsigned int) D.35827;
          D.35829 = D.35828 * 8;
          D.35830 = D.30372 + D.35829;
          *D.35830 = false_bb;
          <D.35825>:
          D.30408 = cfg->real_offset;
          false_bb->real_offset = D.30408;
          <D.35809>:
          bblock.106 = cfg->cbb;
          mono_link_bblock (cfg, bblock.106, true_bb);
          bblock.106 = cfg->cbb;
          mono_link_bblock (cfg, bblock.106, false_bb);
          if (sp != stack_start) goto <D.35831>; else goto <D.35832>;
          <D.35831>:
          sp.71 = (long int) sp;
          stack_start.72 = (long int) stack_start;
          D.31013 = sp.71 - stack_start.72;
          D.31014 = D.31013 /[ex] 8;
          D.31015 = (int) D.31014;
          handle_stack_args (cfg, stack_start, D.31015);
          sp = stack_start;
          D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.31016 = D.30634 & 262144;
          if (D.31016 != 0) goto <D.35833>; else goto <D.35834>;
          <D.35833>:
          D.30389 = cfg->gsharedvt;
          if (D.30389 != 0) goto <D.35835>; else goto <D.35836>;
          <D.35835>:
          D.30322 = cfg->verbose_level;
          if (D.30322 > 2) goto <D.35837>; else goto <D.35838>;
          <D.35837>:
          printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
          <D.35838>:
          mono_cfg_set_exception (cfg, 11);
          goto exception_exit;
          <D.35836>:
          D.35839 = mini_get_debug_options ();
          D.35840 = D.35839->break_on_unverified;
          if (D.35840 != 0) goto <D.35841>; else goto unverified;
          <D.35841>:
          raise (5);
          <D.35834>:
          <D.35832>:
          if (0 != 0) goto <D.35842>; else goto <D.35843>;
          <D.35842>:
          D.35844 = alloc_ireg (cfg);
          dreg = (int) D.35844;
          {
            struct MonoInst * inst;

            D.30241 = cfg->mempool;
            inst = mono_mempool_alloc (D.30241, 80);
            inst->data.op[1].const_val = 0;
            D.35845 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.35845;
            inst->prev = 0B;
            D.35846 = inst->prev;
            inst->next = D.35846;
            inst->opcode = 362;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.35847 = inst->sreg3;
            inst->sreg2 = D.35847;
            D.35848 = inst->sreg2;
            inst->sreg1 = D.35848;
            D.30461 = cfg->ip;
            inst->cil_code = D.30461;
            inst->dreg = dreg;
            inst->data.op[0].const_val = 0;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.35849>; else goto <D.35850>;
            <D.35849>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = inst;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            inst->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            goto <D.35851>;
            <D.35850>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.35851>:
          }
          {
            struct MonoInst * inst;

            D.30241 = cfg->mempool;
            inst = mono_mempool_alloc (D.30241, 80);
            inst->data.op[1].const_val = 0;
            D.35852 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.35852;
            inst->prev = 0B;
            D.35853 = inst->prev;
            inst->next = D.35853;
            inst->opcode = 323;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.35854 = inst->sreg3;
            inst->sreg2 = D.35854;
            D.35855 = inst->sreg2;
            inst->sreg1 = D.35855;
            D.30461 = cfg->ip;
            inst->cil_code = D.30461;
            inst->dreg = -1;
            inst->sreg1 = dreg;
            D.35856 = is_true == 0;
            D.35857 = (int) D.35856;
            D.35858 = (long int) D.35857;
            inst->data.op[1].const_val = D.35858;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.35859>; else goto <D.35860>;
            <D.35859>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = inst;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            inst->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            goto <D.35861>;
            <D.35860>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.35861>:
          }
          {
            struct MonoInst * ins;

            D.30241 = cfg->mempool;
            ins = mono_mempool_alloc (D.30241, 80);
            ins->data.op[1].const_val = 0;
            D.35862 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.35862;
            ins->prev = 0B;
            D.35863 = ins->prev;
            ins->next = D.35863;
            ins->opcode = 648;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.35864 = ins->sreg3;
            ins->sreg2 = D.35864;
            D.35865 = ins->sreg2;
            ins->sreg1 = D.35865;
            D.30461 = cfg->ip;
            ins->cil_code = D.30461;
            D.30241 = cfg->mempool;
            D.35866 = mono_mempool_alloc (D.30241, 16);
            ins->data.op[1].many_blocks = D.35866;
            D.35867 = ins->data.op[1].many_blocks;
            *D.35867 = true_bb;
            D.35867 = ins->data.op[1].many_blocks;
            D.35868 = D.35867 + 8;
            *D.35868 = false_bb;
            bblock.106 = cfg->cbb;
            mono_link_bblock (cfg, bblock.106, true_bb);
            bblock.106 = cfg->cbb;
            mono_link_bblock (cfg, bblock.106, false_bb);
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.35869>; else goto <D.35870>;
            <D.35869>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = ins;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            ins->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            goto <D.35871>;
            <D.35870>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.35871>:
          }
          goto <D.35872>;
          <D.35843>:
          D.30241 = cfg->mempool;
          ins = mono_mempool_alloc (D.30241, 80);
          ins->data.op[1].const_val = 0;
          D.30457 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.30457;
          ins->prev = 0B;
          D.30458 = ins->prev;
          ins->next = D.30458;
          ins->opcode = 442;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.30459 = ins->sreg3;
          ins->sreg2 = D.30459;
          D.30460 = ins->sreg2;
          ins->sreg1 = D.30460;
          D.30461 = cfg->ip;
          ins->cil_code = D.30461;
          if (is_true != 0) goto <D.35874>; else goto <D.35875>;
          <D.35874>:
          iftmp.186 = true_bb;
          goto <D.35876>;
          <D.35875>:
          iftmp.186 = false_bb;
          <D.35876>:
          ins->data.op[0].target_block = iftmp.186;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.35877>; else goto <D.35878>;
          <D.35877>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = ins;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          ins->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          goto <D.35879>;
          <D.35878>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.35879>:
          <D.35872>:
          start_new_bblock = 1;
          goto <D.27394>;
        }
        <D.35747>:
        <D.35755>:
        <D.35752>:
        <D.35750>:
        sp.187 = sp;
        sp = sp.187 + 8;
        klass.144 = klass;
        D.35881 = handle_box (cfg, val, klass.144, context_used, &bblock);
        *sp.187 = D.35881;
        D.30793 = cfg->exception_type;
        if (D.30793 != 0) goto exception_exit; else goto <D.35882>;
        <D.35882>:
        ip = ip + 5;
        inline_costs = inline_costs + 1;
        goto <D.27394>;
      }
      <D.27773>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.35883>; else goto <D.35884>;
      <D.35883>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.35885>; else goto <D.35886>;
      <D.35885>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.35887>; else goto <D.35888>;
      <D.35887>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35888>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35886>:
      D.35889 = mini_get_debug_options ();
      D.35890 = D.35889->break_on_unverified;
      if (D.35890 != 0) goto <D.35891>; else goto unverified;
      <D.35891>:
      raise (5);
      <D.35884>:
      sp = sp + 18446744073709551608;
      D.31664 = ip + 5;
      if (D.31664 > end) goto <D.35892>; else goto <D.35893>;
      <D.35892>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.35894>; else goto <D.35895>;
      <D.35894>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.35896>; else goto <D.35897>;
      <D.35896>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.35897>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.35895>:
      D.35898 = mini_get_debug_options ();
      D.35899 = D.35898->break_on_unverified;
      if (D.35899 != 0) goto <D.35900>; else goto unverified;
      <D.35900>:
      raise (5);
      <D.35893>:
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31684 = D.31683 << 24;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31685 = D.31683 >> 8;
      D.31686 = D.31685 & 65280;
      D.31687 = D.31684 | D.31686;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31688 = D.31683 << 8;
      D.31689 = D.31688 & 16711680;
      D.31690 = D.31687 | D.31689;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31691 = D.31683 >> 24;
      token = D.31690 | D.31691;
      klass.188 = mini_get_class (method, token, generic_context);
      klass = klass.188;
      klass.144 = klass;
      if (klass.144 == 0B) goto <D.35902>; else goto <D.35904>;
      <D.35904>:
      klass.144 = klass;
      D.34697 = klass.144->exception_type;
      if (D.34697 != 0) goto <D.35902>; else goto <D.35903>;
      <D.35902>:
      klass.144 = klass;
      cfg->exception_ptr = klass.144;
      D.35905 = mini_get_debug_options ();
      D.35906 = D.35905->break_on_unverified;
      if (D.35906 != 0) goto <D.35907>; else goto load_error;
      <D.35907>:
      raise (5);
      <D.35903>:
      klass.144 = klass;
      mono_save_token_info (cfg, image, token, klass.144);
      klass.144 = klass;
      context_used = mini_class_check_context_used (cfg, klass.144);
      klass.144 = klass;
      D.35908 = mono_class_is_nullable (klass.144);
      if (D.35908 != 0) goto <D.35909>; else goto <D.35910>;
      <D.35909>:
      {
        struct MonoInst * val;

        D.31240 = *sp;
        klass.144 = klass;
        val = handle_unbox_nullable (cfg, D.31240, klass.144, context_used);
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 314;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        D.35912 = val->dreg;
        D.35913 = (unsigned int) D.35912;
        D.31341 = cfg->vreg_to_inst_len;
        if (D.35913 < D.31341) goto <D.35914>; else goto <D.35915>;
        <D.35914>:
        D.31344 = cfg->vreg_to_inst;
        D.35912 = val->dreg;
        D.35916 = (long unsigned int) D.35912;
        D.35917 = D.35916 * 8;
        D.35918 = D.31344 + D.35917;
        iftmp.189 = *D.35918;
        goto <D.35919>;
        <D.35915>:
        iftmp.189 = 0B;
        <D.35919>:
        ins->data.op[0].p = iftmp.189;
        D.35912 = val->dreg;
        D.35913 = (unsigned int) D.35912;
        D.31341 = cfg->vreg_to_inst_len;
        if (D.35913 < D.31341) goto <D.35921>; else goto <D.35922>;
        <D.35921>:
        D.31344 = cfg->vreg_to_inst;
        D.35912 = val->dreg;
        D.35916 = (long unsigned int) D.35912;
        D.35917 = D.35916 * 8;
        D.35918 = D.31344 + D.35917;
        iftmp.190 = *D.35918;
        goto <D.35923>;
        <D.35922>:
        iftmp.190 = 0B;
        <D.35923>:
        D.35912 = val->dreg;
        D.35913 = (unsigned int) D.35912;
        D.31341 = cfg->vreg_to_inst_len;
        if (D.35913 < D.31341) goto <D.35925>; else goto <D.35926>;
        <D.35925>:
        D.31344 = cfg->vreg_to_inst;
        D.35912 = val->dreg;
        D.35916 = (long unsigned int) D.35912;
        D.35917 = D.35916 * 8;
        D.35918 = D.31344 + D.35917;
        iftmp.191 = *D.35918;
        goto <D.35927>;
        <D.35926>:
        iftmp.191 = 0B;
        <D.35927>:
        D.35928 = iftmp.191->flags;
        D.35929 = D.35928 | 16;
        iftmp.190->flags = D.35929;
        ins->type = 5;
        D.35912 = val->dreg;
        D.35913 = (unsigned int) D.35912;
        D.31341 = cfg->vreg_to_inst_len;
        if (D.35913 < D.31341) goto <D.35931>; else goto <D.35932>;
        <D.35931>:
        D.31344 = cfg->vreg_to_inst;
        D.35912 = val->dreg;
        D.35916 = (long unsigned int) D.35912;
        D.35917 = D.35916 * 8;
        D.35918 = D.31344 + D.35917;
        iftmp.192 = *D.35918;
        goto <D.35933>;
        <D.35932>:
        iftmp.192 = 0B;
        <D.35933>:
        D.35934 = iftmp.192->klass;
        ins->klass = D.35934;
        D.35935 = alloc_dreg (cfg, 5);
        D.35936 = (int) D.35935;
        ins->dreg = D.35936;
        cfg->has_indirection = 1;
        D.30389 = cfg->gsharedvt;
        D.31326 = D.30389 != 0;
        D.31327 = (long int) D.31326;
        D.31328 = __builtin_expect (D.31327, 0);
        if (D.31328 != 0) goto <D.35937>; else goto <D.35938>;
        <D.35937>:
        D.35912 = val->dreg;
        D.35913 = (unsigned int) D.35912;
        D.31341 = cfg->vreg_to_inst_len;
        if (D.35913 < D.31341) goto <D.35940>; else goto <D.35941>;
        <D.35940>:
        D.31344 = cfg->vreg_to_inst;
        D.35912 = val->dreg;
        D.35916 = (long unsigned int) D.35912;
        D.35917 = D.35916 * 8;
        D.35918 = D.31344 + D.35917;
        iftmp.193 = *D.35918;
        goto <D.35942>;
        <D.35941>:
        iftmp.193 = 0B;
        <D.35942>:
        D.35943 = iftmp.193->data.op[1].vtype;
        D.35944 = mini_is_gsharedvt_variable_type (cfg, D.35943);
        if (D.35944 != 0) goto <D.35945>; else goto <D.35946>;
        <D.35945>:
        handle_gsharedvt_ldaddr (cfg);
        <D.35946>:
        <D.35938>:
        if (0 != 0) goto <D.35947>; else goto <D.35948>;
        <D.35947>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.35912 = val->dreg;
          D.35913 = (unsigned int) D.35912;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.35913 < D.31341) goto <D.35951>; else goto <D.35952>;
          <D.35951>:
          D.31344 = cfg->vreg_to_inst;
          D.35912 = val->dreg;
          D.35916 = (long unsigned int) D.35912;
          D.35917 = D.35916 * 8;
          D.35918 = D.31344 + D.35917;
          iftmp.195 = *D.35918;
          goto <D.35953>;
          <D.35952>:
          iftmp.195 = 0B;
          <D.35953>:
          D.35954 = iftmp.195->dreg;
          D.35955 = D.35954 + 1;
          D.35956 = (unsigned int) D.35955;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.35956 < D.31341) goto <D.35957>; else goto <D.35958>;
          <D.35957>:
          D.31344 = cfg->vreg_to_inst;
          D.35912 = val->dreg;
          D.35913 = (unsigned int) D.35912;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.35913 < D.31341) goto <D.35960>; else goto <D.35961>;
          <D.35960>:
          D.31344 = cfg->vreg_to_inst;
          D.35912 = val->dreg;
          D.35916 = (long unsigned int) D.35912;
          D.35917 = D.35916 * 8;
          D.35918 = D.31344 + D.35917;
          iftmp.196 = *D.35918;
          goto <D.35962>;
          <D.35961>:
          iftmp.196 = 0B;
          <D.35962>:
          D.35963 = iftmp.196->dreg;
          D.35964 = (sizetype) D.35963;
          D.35965 = D.35964 + 1;
          D.35966 = D.35965 * 8;
          D.35967 = D.31344 + D.35966;
          iftmp.194 = *D.35967;
          goto <D.35968>;
          <D.35958>:
          iftmp.194 = 0B;
          <D.35968>:
          var1 = iftmp.194;
          D.35912 = val->dreg;
          D.35913 = (unsigned int) D.35912;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.35913 < D.31341) goto <D.35971>; else goto <D.35972>;
          <D.35971>:
          D.31344 = cfg->vreg_to_inst;
          D.35912 = val->dreg;
          D.35916 = (long unsigned int) D.35912;
          D.35917 = D.35916 * 8;
          D.35918 = D.31344 + D.35917;
          iftmp.198 = *D.35918;
          goto <D.35973>;
          <D.35972>:
          iftmp.198 = 0B;
          <D.35973>:
          D.35974 = iftmp.198->dreg;
          D.35975 = D.35974 + 2;
          D.35976 = (unsigned int) D.35975;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.35976 < D.31341) goto <D.35977>; else goto <D.35978>;
          <D.35977>:
          D.31344 = cfg->vreg_to_inst;
          D.35912 = val->dreg;
          D.35913 = (unsigned int) D.35912;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.35913 < D.31341) goto <D.35980>; else goto <D.35981>;
          <D.35980>:
          D.31344 = cfg->vreg_to_inst;
          D.35912 = val->dreg;
          D.35916 = (long unsigned int) D.35912;
          D.35917 = D.35916 * 8;
          D.35918 = D.31344 + D.35917;
          iftmp.199 = *D.35918;
          goto <D.35982>;
          <D.35981>:
          iftmp.199 = 0B;
          <D.35982>:
          D.35983 = iftmp.199->dreg;
          D.35984 = (sizetype) D.35983;
          D.35985 = D.35984 + 2;
          D.35986 = D.35985 * 8;
          D.35987 = D.31344 + D.35986;
          iftmp.197 = *D.35987;
          goto <D.35988>;
          <D.35978>:
          iftmp.197 = 0B;
          <D.35988>:
          var2 = iftmp.197;
          D.35989 = var1 == 0B;
          D.35990 = (long int) D.35989;
          D.35991 = __builtin_expect (D.35990, 0);
          if (D.35991 != 0) goto <D.35992>; else goto <D.35993>;
          <D.35992>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9818, "var1");
          <D.35993>:
          D.35994 = var2 == 0B;
          D.35995 = (long int) D.35994;
          D.35996 = __builtin_expect (D.35995, 0);
          if (D.35996 != 0) goto <D.35997>; else goto <D.35998>;
          <D.35997>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9818, "var2");
          <D.35998>:
          D.35999 = var1->flags;
          D.36000 = D.35999 | 16;
          var1->flags = D.36000;
          D.36001 = var2->flags;
          D.36002 = D.36001 | 16;
          var2->flags = D.36002;
        }
        <D.35948>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.36003>; else goto <D.36004>;
        <D.36003>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.36005>;
        <D.36004>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.36005>:
        sp.200 = sp;
        sp = sp.200 + 8;
        *sp.200 = ins;
      }
      goto <D.36007>;
      <D.35910>:
      klass.144 = klass;
      ins = handle_unbox (cfg, klass.144, sp, context_used);
      sp.201 = sp;
      sp = sp.201 + 8;
      *sp.201 = ins;
      <D.36007>:
      ip = ip + 5;
      inline_costs = inline_costs + 2;
      goto <D.27394>;
      <D.27777>:
      <D.27778>:
      <D.27779>:
      <D.27780>:
      <D.27781>:
      <D.27782>:
      {
        struct MonoClassField * field;
        int costs;
        guint foffset;
        gboolean is_instance;
        int op;
        void * addr;
        gboolean is_special_static;
        struct MonoType * ftype;
        struct MonoInst * store_val;
        struct MonoInst * thread_ins;

        addr = 0B;
        store_val = 0B;
        D.31121 = *ip;
        op = (int) D.31121;
        op.202 = (unsigned int) op;
        D.36010 = op.202 + 4294967173;
        D.36011 = D.36010 <= 2;
        is_instance = (gboolean) D.36011;
        if (is_instance != 0) goto <D.36012>; else goto <D.36013>;
        <D.36012>:
        if (op == 125) goto <D.36014>; else goto <D.36015>;
        <D.36014>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        if (D.31013 <= 15) goto <D.36016>; else goto <D.36017>;
        <D.36016>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.36018>; else goto <D.36019>;
        <D.36018>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.36020>; else goto <D.36021>;
        <D.36020>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.36021>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.36019>:
        D.36022 = mini_get_debug_options ();
        D.36023 = D.36022->break_on_unverified;
        if (D.36023 != 0) goto <D.36024>; else goto unverified;
        <D.36024>:
        raise (5);
        <D.36017>:
        sp = sp + 18446744073709551600;
        store_val = MEM[(struct MonoInst * *)sp + 8B];
        goto <D.36025>;
        <D.36015>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        if (D.31013 <= 7) goto <D.36026>; else goto <D.36027>;
        <D.36026>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.36028>; else goto <D.36029>;
        <D.36028>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.36030>; else goto <D.36031>;
        <D.36030>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.36031>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.36029>:
        D.36032 = mini_get_debug_options ();
        D.36033 = D.36032->break_on_unverified;
        if (D.36033 != 0) goto <D.36034>; else goto unverified;
        <D.36034>:
        raise (5);
        <D.36027>:
        sp = sp + 18446744073709551608;
        <D.36025>:
        D.31240 = *sp;
        D.32922 = D.31240->type;
        D.36037 = D.32922 + 255;
        if (D.36037 <= 1) goto <D.36035>; else goto <D.36038>;
        <D.36038>:
        D.31240 = *sp;
        D.32922 = D.31240->type;
        if (D.32922 == 4) goto <D.36035>; else goto <D.36036>;
        <D.36035>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.36039>; else goto <D.36040>;
        <D.36039>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.36041>; else goto <D.36042>;
        <D.36041>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.36042>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.36040>:
        D.36043 = mini_get_debug_options ();
        D.36044 = D.36043->break_on_unverified;
        if (D.36044 != 0) goto <D.36045>; else goto unverified;
        <D.36045>:
        raise (5);
        <D.36036>:
        D.31121 = *ip;
        if (D.31121 != 123) goto <D.36046>; else goto <D.36047>;
        <D.36046>:
        D.31240 = *sp;
        D.32922 = D.31240->type;
        if (D.32922 == 7) goto <D.36048>; else goto <D.36049>;
        <D.36048>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.36050>; else goto <D.36051>;
        <D.36050>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.36052>; else goto <D.36053>;
        <D.36052>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.36053>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.36051>:
        D.36054 = mini_get_debug_options ();
        D.36055 = D.36054->break_on_unverified;
        if (D.36055 != 0) goto <D.36056>; else goto unverified;
        <D.36056>:
        raise (5);
        <D.36049>:
        <D.36047>:
        goto <D.36057>;
        <D.36013>:
        if (op == 128) goto <D.36058>; else goto <D.36059>;
        <D.36058>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        if (D.31013 <= 7) goto <D.36060>; else goto <D.36061>;
        <D.36060>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.36062>; else goto <D.36063>;
        <D.36062>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.36064>; else goto <D.36065>;
        <D.36064>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.36065>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.36063>:
        D.36066 = mini_get_debug_options ();
        D.36067 = D.36066->break_on_unverified;
        if (D.36067 != 0) goto <D.36068>; else goto unverified;
        <D.36068>:
        raise (5);
        <D.36061>:
        sp = sp + 18446744073709551608;
        store_val = *sp;
        <D.36059>:
        <D.36057>:
        D.31664 = ip + 5;
        if (D.31664 > end) goto <D.36069>; else goto <D.36070>;
        <D.36069>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.36071>; else goto <D.36072>;
        <D.36071>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.36073>; else goto <D.36074>;
        <D.36073>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.36074>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.36072>:
        D.36075 = mini_get_debug_options ();
        D.36076 = D.36075->break_on_unverified;
        if (D.36076 != 0) goto <D.36077>; else goto unverified;
        <D.36077>:
        raise (5);
        <D.36070>:
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31684 = D.31683 << 24;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31685 = D.31683 >> 8;
        D.31686 = D.31685 & 65280;
        D.31687 = D.31684 | D.31686;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31688 = D.31683 << 8;
        D.31689 = D.31688 & 16711680;
        D.31690 = D.31687 | D.31689;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31691 = D.31683 >> 24;
        token = D.31690 | D.31691;
        D.30183 = BIT_FIELD_REF <*method, 64, 256>;
        D.30184 = D.30183 & 4467570830351532032;
        if (D.30184 != 0) goto <D.36078>; else goto <D.36079>;
        <D.36078>:
        field = mono_method_get_wrapper_data (method, token);
        klass.203 = field->parent;
        klass = klass.203;
        goto <D.36081>;
        <D.36079>:
        field = mono_field_from_token (image, token, &klass, generic_context);
        <D.36081>:
        if (field == 0B) goto <D.36082>; else goto <D.36083>;
        <D.36082>:
        D.36084 = mini_get_debug_options ();
        D.36085 = D.36084->break_on_unverified;
        if (D.36085 != 0) goto <D.36086>; else goto load_error;
        <D.36086>:
        raise (5);
        <D.36083>:
        if (dont_verify == 0) goto <D.36087>; else goto <D.36088>;
        <D.36087>:
        D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.32142 = D.30634 & 131072;
        if (D.32142 == 0) goto <D.36089>; else goto <D.36090>;
        <D.36089>:
        D.36091 = mono_method_can_access_field (method, field);
        if (D.36091 == 0) goto <D.36092>; else goto <D.36093>;
        <D.36092>:
        {
          char * method_fname;
          char * field_fname;

          method_fname = mono_method_full_name (method, 1);
          field_fname = mono_field_full_name (field);
          mono_cfg_set_exception (cfg, 10);
          D.36094 = monoeg_g_strdup_printf ("Field `%s\' is inaccessible from method `%s\'\n", field_fname, method_fname);
          cfg->exception_message = D.36094;
          monoeg_g_free (method_fname);
          monoeg_g_free (field_fname);
          goto exception_exit;
        }
        <D.36093>:
        <D.36090>:
        <D.36088>:
        klass.144 = klass;
        mono_class_init (klass.144);
        if (is_instance != 0) goto <D.36095>; else goto <D.36096>;
        <D.36095>:
        D.31121 = *ip;
        if (D.31121 != 124) goto <D.36097>; else goto <D.36098>;
        <D.36097>:
        D.36099 = is_magic_tls_access (field);
        if (D.36099 != 0) goto <D.36100>; else goto <D.36101>;
        <D.36100>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.36102>; else goto <D.36103>;
        <D.36102>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.36104>; else goto <D.36105>;
        <D.36104>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.36105>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.36103>:
        D.36106 = mini_get_debug_options ();
        D.36107 = D.36106->break_on_unverified;
        if (D.36107 != 0) goto <D.36108>; else goto unverified;
        <D.36108>:
        raise (5);
        <D.36101>:
        <D.36098>:
        <D.36096>:
        if (is_instance == 0) goto <D.36109>; else goto <D.36110>;
        <D.36109>:
        D.36111 = mono_security_get_mode ();
        if (D.36111 == 1) goto <D.36112>; else goto <D.36113>;
        <D.36112>:
        bblock.64 = bblock;
        ensure_method_is_allowed_to_access_field (cfg, method, field, bblock.64, ip);
        <D.36113>:
        <D.36110>:
        if (is_instance != 0) goto <D.36114>; else goto <D.36115>;
        <D.36114>:
        D.36116 = field->type;
        D.36117 = D.36116->attrs;
        D.36118 = (int) D.36117;
        D.36119 = D.36118 & 16;
        if (D.36119 != 0) goto <D.36120>; else goto <D.36121>;
        <D.36120>:
        switch (op) <default: <D.27799>, case 123: <D.27795>, case 124: <D.27798>, case 125: <D.27797>>
        <D.27795>:
        op = 126;
        goto <D.27796>;
        <D.27797>:
        op = 128;
        goto <D.27796>;
        <D.27798>:
        op = 127;
        goto <D.27796>;
        <D.27799>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 9915);
        <D.27796>:
        is_instance = 0;
        <D.36121>:
        <D.36115>:
        klass.144 = klass;
        context_used = mini_class_check_context_used (cfg, klass.144);
        klass.144 = klass;
        D.35477 = BIT_FIELD_REF <*klass.144, 64, 256>;
        D.36123 = D.35477 & 1152921504606846976;
        if (D.36123 != 0) goto <D.36124>; else goto <D.36125>;
        <D.36124>:
        D.36126 = field->offset;
        D.36127 = (unsigned int) D.36126;
        iftmp.204 = D.36127 + 4294967280;
        goto <D.36128>;
        <D.36125>:
        D.36126 = field->offset;
        iftmp.204 = (guint) D.36126;
        <D.36128>:
        foffset = iftmp.204;
        if (op == 125) goto <D.36129>; else goto <D.36130>;
        <D.36129>:
        D.36116 = field->type;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        D.36131 = target_type_is_incompatible (cfg, D.36116, D.32379);
        if (D.36131 != 0) goto <D.36132>; else goto <D.36133>;
        <D.36132>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.36134>; else goto <D.36135>;
        <D.36134>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.36136>; else goto <D.36137>;
        <D.36136>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.36137>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.36135>:
        D.36138 = mini_get_debug_options ();
        D.36139 = D.36138->break_on_unverified;
        if (D.36139 != 0) goto <D.36140>; else goto unverified;
        <D.36140>:
        raise (5);
        <D.36133>:
        klass.144 = klass;
        D.35477 = BIT_FIELD_REF <*klass.144, 64, 256>;
        D.35478 = D.35477 & 2199023255552;
        if (D.35478 != 0) goto <D.36145>; else goto <D.36141>;
        <D.36145>:
        D.30211 = cfg->method;
        D.36146 = mono_method_signature (D.30211);
        D.36147 = BIT_FIELD_REF <*D.36146, 64, 64>;
        D.36148 = D.36147 & 512;
        if (D.36148 == 0) goto <D.36142>; else goto <D.36149>;
        <D.36149>:
        D.31240 = *sp;
        D.32926 = D.31240->opcode;
        if (D.32926 != 424) goto <D.36142>; else goto <D.36150>;
        <D.36150>:
        D.31240 = *sp;
        D.36151 = D.31240->sreg1;
        D.30842 = cfg->args;
        D.30843 = *D.30842;
        D.30857 = D.30843->dreg;
        if (D.36151 != D.30857) goto <D.36142>; else goto <D.36141>;
        <D.36141>:
        klass.144 = klass;
        D.35477 = BIT_FIELD_REF <*klass.144, 64, 256>;
        D.36152 = D.35477 & 1099511627776;
        if (D.36152 != 0) goto <D.36142>; else goto <D.36153>;
        <D.36153>:
        D.36154 = mono_defaults.marshalbyrefobject_class;
        klass.144 = klass;
        if (D.36154 == klass.144) goto <D.36142>; else goto <D.36143>;
        <D.36142>:
        {
          struct MonoMethod * stfld_wrapper;
          struct MonoInst * iargs[5];

          try
            {
              D.36116 = field->type;
              stfld_wrapper = mono_marshal_get_stfld_wrapper (D.36116);
              D.30389 = cfg->gsharedvt;
              if (D.30389 != 0) goto <D.36155>; else goto <D.36156>;
              <D.36155>:
              D.30178 = method->klass;
              D.31934 = D.30178->name_space;
              D.30178 = method->klass;
              D.31935 = D.30178->name;
              D.31936 = method->name;
              D.31937 = method->signature;
              D.31938 = D.31937->param_count;
              D.31939 = (int) D.31938;
              D.36157 = mono_opcode_name (op);
              D.36158 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.31934, D.31935, D.31936, D.31939, D.36157, "method-to-ir.c", 9933);
              cfg->exception_message = D.36158;
              D.30322 = cfg->verbose_level;
              if (D.30322 > 1) goto <D.36159>; else goto <D.36160>;
              <D.36159>:
              D.31944 = cfg->exception_message;
              printf ("%s\n", D.31944);
              <D.36160>:
              mono_cfg_set_exception (cfg, 11);
              goto exception_exit;
              <D.36156>:
              D.31240 = *sp;
              iargs[0] = D.31240;
              D.30241 = cfg->mempool;
              D.36161 = mono_mempool_alloc (D.30241, 80);
              iargs[1] = D.36161;
              D.36162 = iargs[1];
              D.36162 = iargs[1];
              D.36162->data.op[1].const_val = 0;
              D.36163 = D.36162->data.op[1].const_val;
              D.36162->data.op[0].const_val = D.36163;
              D.36162 = iargs[1];
              D.36162 = iargs[1];
              D.36162->prev = 0B;
              D.36164 = D.36162->prev;
              D.36162->next = D.36164;
              D.36162 = iargs[1];
              D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.30635 = D.30634 & 33554432;
              if (D.30635 != 0) goto <D.36166>; else goto <D.36167>;
              <D.36166>:
              iftmp.205 = 732;
              goto <D.36168>;
              <D.36167>:
              iftmp.205 = 363;
              <D.36168>:
              D.36162->opcode = iftmp.205;
              D.36162 = iargs[1];
              D.36162->flags = 0;
              D.36162 = iargs[1];
              D.36162->type = 0;
              D.36162 = iargs[1];
              D.36162->dreg = -1;
              D.36162 = iargs[1];
              D.36162 = iargs[1];
              D.36162 = iargs[1];
              D.36162->sreg3 = -1;
              D.36169 = D.36162->sreg3;
              D.36162->sreg2 = D.36169;
              D.36170 = D.36162->sreg2;
              D.36162->sreg1 = D.36170;
              D.36162 = iargs[1];
              D.30461 = cfg->ip;
              D.36162->cil_code = D.30461;
              D.36162 = iargs[1];
              klass.144 = klass;
              D.36162->data.op[0].p = klass.144;
              D.36162 = iargs[1];
              D.36162->data.op[1].src = 11B;
              D.36162 = iargs[1];
              D.36162->type = 3;
              D.36162 = iargs[1];
              D.36171 = alloc_dreg (cfg, 3);
              D.36172 = (int) D.36171;
              D.36162->dreg = D.36172;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.36173>; else goto <D.36174>;
              <D.36173>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36162 = iargs[1];
              D.30490->next = D.36162;
              D.36162 = iargs[1];
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36162->prev = D.30490;
              bblock.106 = cfg->cbb;
              D.36162 = iargs[1];
              bblock.106->last_ins = D.36162;
              goto <D.36175>;
              <D.36174>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              D.36162 = iargs[1];
              bblock.106->last_ins = D.36162;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.36175>:
              D.30241 = cfg->mempool;
              D.36176 = mono_mempool_alloc (D.30241, 80);
              iargs[2] = D.36176;
              D.36177 = iargs[2];
              D.36177 = iargs[2];
              D.36177->data.op[1].const_val = 0;
              D.36178 = D.36177->data.op[1].const_val;
              D.36177->data.op[0].const_val = D.36178;
              D.36177 = iargs[2];
              D.36177 = iargs[2];
              D.36177->prev = 0B;
              D.36179 = D.36177->prev;
              D.36177->next = D.36179;
              D.36177 = iargs[2];
              D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.30635 = D.30634 & 33554432;
              if (D.30635 != 0) goto <D.36181>; else goto <D.36182>;
              <D.36181>:
              iftmp.206 = 732;
              goto <D.36183>;
              <D.36182>:
              iftmp.206 = 363;
              <D.36183>:
              D.36177->opcode = iftmp.206;
              D.36177 = iargs[2];
              D.36177->flags = 0;
              D.36177 = iargs[2];
              D.36177->type = 0;
              D.36177 = iargs[2];
              D.36177->dreg = -1;
              D.36177 = iargs[2];
              D.36177 = iargs[2];
              D.36177 = iargs[2];
              D.36177->sreg3 = -1;
              D.36184 = D.36177->sreg3;
              D.36177->sreg2 = D.36184;
              D.36185 = D.36177->sreg2;
              D.36177->sreg1 = D.36185;
              D.36177 = iargs[2];
              D.30461 = cfg->ip;
              D.36177->cil_code = D.30461;
              D.36177 = iargs[2];
              D.36177->data.op[0].p = field;
              D.36177 = iargs[2];
              D.36177->data.op[1].src = 13B;
              D.36177 = iargs[2];
              D.36177->type = 3;
              D.36177 = iargs[2];
              D.36186 = alloc_dreg (cfg, 3);
              D.36187 = (int) D.36186;
              D.36177->dreg = D.36187;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.36188>; else goto <D.36189>;
              <D.36188>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36177 = iargs[2];
              D.30490->next = D.36177;
              D.36177 = iargs[2];
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36177->prev = D.30490;
              bblock.106 = cfg->cbb;
              D.36177 = iargs[2];
              bblock.106->last_ins = D.36177;
              goto <D.36190>;
              <D.36189>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              D.36177 = iargs[2];
              bblock.106->last_ins = D.36177;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.36190>:
              D.30241 = cfg->mempool;
              D.36191 = mono_mempool_alloc (D.30241, 80);
              iargs[3] = D.36191;
              D.36192 = iargs[3];
              D.36192 = iargs[3];
              D.36192->data.op[1].const_val = 0;
              D.36193 = D.36192->data.op[1].const_val;
              D.36192->data.op[0].const_val = D.36193;
              D.36192 = iargs[3];
              D.36192 = iargs[3];
              D.36192->prev = 0B;
              D.36194 = D.36192->prev;
              D.36192->next = D.36194;
              D.36192 = iargs[3];
              D.36192->opcode = 362;
              D.36192 = iargs[3];
              D.36192->flags = 0;
              D.36192 = iargs[3];
              D.36192->type = 0;
              D.36192 = iargs[3];
              D.36192->dreg = -1;
              D.36192 = iargs[3];
              D.36192 = iargs[3];
              D.36192 = iargs[3];
              D.36192->sreg3 = -1;
              D.36195 = D.36192->sreg3;
              D.36192->sreg2 = D.36195;
              D.36196 = D.36192->sreg2;
              D.36192->sreg1 = D.36196;
              D.36192 = iargs[3];
              D.30461 = cfg->ip;
              D.36192->cil_code = D.30461;
              D.36192 = iargs[3];
              klass.144 = klass;
              D.35477 = BIT_FIELD_REF <*klass.144, 64, 256>;
              D.36123 = D.35477 & 1152921504606846976;
              if (D.36123 != 0) goto <D.36198>; else goto <D.36199>;
              <D.36198>:
              D.36126 = field->offset;
              D.36200 = (long unsigned int) D.36126;
              D.36201 = D.36200 + 18446744073709551600;
              iftmp.207 = (mgreg_t) D.36201;
              goto <D.36202>;
              <D.36199>:
              D.36126 = field->offset;
              iftmp.207 = (mgreg_t) D.36126;
              <D.36202>:
              D.36192->data.op[0].const_val = iftmp.207;
              D.36192 = iargs[3];
              D.36192->type = 1;
              D.36192 = iargs[3];
              D.36203 = alloc_dreg (cfg, 1);
              D.36204 = (int) D.36203;
              D.36192->dreg = D.36204;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.36205>; else goto <D.36206>;
              <D.36205>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36192 = iargs[3];
              D.30490->next = D.36192;
              D.36192 = iargs[3];
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36192->prev = D.30490;
              bblock.106 = cfg->cbb;
              D.36192 = iargs[3];
              bblock.106->last_ins = D.36192;
              goto <D.36207>;
              <D.36206>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              D.36192 = iargs[3];
              bblock.106->last_ins = D.36192;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.36207>:
              D.35164 = MEM[(struct MonoInst * *)sp + 8B];
              iargs[4] = D.35164;
              D.30632 = cfg->opt;
              D.32993 = D.30632 & 4;
              if (D.32993 != 0) goto <D.36208>; else goto <D.36211>;
              <D.36211>:
              D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.30635 = D.30634 & 33554432;
              if (D.30635 != 0) goto <D.36208>; else goto <D.36209>;
              <D.36208>:
              D.36212 = mono_method_signature (stfld_wrapper);
              D.30408 = cfg->real_offset;
              costs = inline_method (cfg, stfld_wrapper, D.36212, &iargs, ip, D.30408, dont_inline, 1);
              D.30793 = cfg->exception_type;
              if (D.30793 != 0) goto exception_exit; else goto <D.36213>;
              <D.36213>:
              D.36214 = costs <= 0;
              D.36215 = (long int) D.36214;
              D.36216 = __builtin_expect (D.36215, 0);
              if (D.36216 != 0) goto <D.36217>; else goto <D.36218>;
              <D.36217>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 9946, "costs > 0");
              <D.36218>:
              D.30408 = cfg->real_offset;
              D.33020 = D.30408 + 5;
              cfg->real_offset = D.33020;
              bblock.106 = cfg->cbb;
              bblock = bblock.106;
              inline_costs = inline_costs + costs;
              goto <D.36210>;
              <D.36209>:
              mono_emit_method_call (cfg, stfld_wrapper, &iargs, 0B);
              <D.36210>:
            }
          finally
            {
              iargs = {CLOBBER};
            }
        }
        goto <D.36144>;
        <D.36143>:
        {
          struct MonoInst * store;

          D.30229 = BIT_FIELD_REF <*cfg, 64, 5632>;
          D.30870 = D.30229 & 144115188075855872;
          if (D.30870 != 0) goto <D.36219>; else goto <D.36220>;
          <D.36219>:
          {
            struct MonoInst * inst;

            D.30241 = cfg->mempool;
            inst = mono_mempool_alloc (D.30241, 80);
            inst->data.op[1].const_val = 0;
            D.36221 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.36221;
            inst->prev = 0B;
            D.36222 = inst->prev;
            inst->next = D.36222;
            inst->opcode = 323;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.36223 = inst->sreg3;
            inst->sreg2 = D.36223;
            D.36224 = inst->sreg2;
            inst->sreg1 = D.36224;
            D.30461 = cfg->ip;
            inst->cil_code = D.30461;
            inst->dreg = -1;
            D.31240 = *sp;
            D.31422 = D.31240->dreg;
            inst->sreg1 = D.31422;
            inst->data.op[1].const_val = 0;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.36225>; else goto <D.36226>;
            <D.36225>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = inst;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            inst->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            goto <D.36227>;
            <D.36226>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.36227>:
          }
          {
            struct MonoInst * inst;

            D.30241 = cfg->mempool;
            inst = mono_mempool_alloc (D.30241, 80);
            inst->data.op[1].const_val = 0;
            D.36228 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.36228;
            inst->prev = 0B;
            D.36229 = inst->prev;
            inst->next = D.36229;
            inst->opcode = 451;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.36230 = inst->sreg3;
            inst->sreg2 = D.36230;
            D.36231 = inst->sreg2;
            inst->sreg1 = D.36231;
            D.30461 = cfg->ip;
            inst->cil_code = D.30461;
            inst->data.op[1].p = "NullReferenceException";
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.36232>; else goto <D.36233>;
            <D.36232>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = inst;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            inst->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            goto <D.36234>;
            <D.36233>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.36234>:
          }
          goto <D.36235>;
          <D.36220>:
          <D.36235>:
          klass.144 = klass;
          D.36236 = mini_is_gsharedvt_klass (cfg, klass.144);
          if (D.36236 != 0) goto <D.36237>; else goto <D.36238>;
          <D.36237>:
          {
            struct MonoInst * offset_ins;

            klass.144 = klass;
            context_used = mini_class_check_context_used (cfg, klass.144);
            offset_ins = emit_get_gsharedvt_info (cfg, field, 15);
            D.36239 = alloc_ireg_mp (cfg);
            dreg = (int) D.36239;
            D.30241 = cfg->mempool;
            ins = mono_mempool_alloc (D.30241, 80);
            ins->data.op[1].const_val = 0;
            D.30457 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.30457;
            ins->prev = 0B;
            D.30458 = ins->prev;
            ins->next = D.30458;
            ins->opcode = 479;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.30459 = ins->sreg3;
            ins->sreg2 = D.30459;
            D.30460 = ins->sreg2;
            ins->sreg1 = D.30460;
            D.30461 = cfg->ip;
            ins->cil_code = D.30461;
            ins->dreg = dreg;
            D.31240 = *sp;
            D.31422 = D.31240->dreg;
            ins->sreg1 = D.31422;
            D.36240 = offset_ins->dreg;
            ins->sreg2 = D.36240;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.36241>; else goto <D.36242>;
            <D.36241>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = ins;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            ins->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            goto <D.36243>;
            <D.36242>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.36243>:
            D.30241 = cfg->mempool;
            store = mono_mempool_alloc (D.30241, 80);
            store->data.op[1].const_val = 0;
            D.36244 = store->data.op[1].const_val;
            store->data.op[0].const_val = D.36244;
            store->prev = 0B;
            D.36245 = store->prev;
            store->next = D.36245;
            D.36116 = field->type;
            D.36246 = mono_type_to_store_membase (cfg, D.36116);
            D.36247 = (short unsigned int) D.36246;
            store->opcode = D.36247;
            store->flags = 0;
            store->type = 0;
            store->dreg = -1;
            store->sreg3 = -1;
            D.36248 = store->sreg3;
            store->sreg2 = D.36248;
            D.36249 = store->sreg2;
            store->sreg1 = D.36249;
            D.30461 = cfg->ip;
            store->cil_code = D.30461;
            D.32378 = sp + 8;
            D.32379 = *D.32378;
            D.32380 = D.32379->dreg;
            store->sreg1 = D.32380;
            store->dreg = dreg;
            store->data.op[0].const_val = 0;
            D.36116 = field->type;
            type_to_eval_stack_type (cfg, D.36116, store);
            D.36116 = field->type;
            D.36250 = mono_class_from_mono_type (D.36116);
            store->klass = D.36250;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.36251>; else goto <D.36252>;
            <D.36251>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = store;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            store->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = store;
            goto <D.36253>;
            <D.36252>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = store;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.36253>:
          }
          goto <D.36254>;
          <D.36238>:
          D.30241 = cfg->mempool;
          store = mono_mempool_alloc (D.30241, 80);
          store->data.op[1].const_val = 0;
          D.36244 = store->data.op[1].const_val;
          store->data.op[0].const_val = D.36244;
          store->prev = 0B;
          D.36245 = store->prev;
          store->next = D.36245;
          D.36116 = field->type;
          D.36255 = mono_type_to_store_membase (cfg, D.36116);
          D.36256 = (short unsigned int) D.36255;
          store->opcode = D.36256;
          store->flags = 0;
          store->type = 0;
          store->dreg = -1;
          store->sreg3 = -1;
          D.36248 = store->sreg3;
          store->sreg2 = D.36248;
          D.36249 = store->sreg2;
          store->sreg1 = D.36249;
          D.30461 = cfg->ip;
          store->cil_code = D.30461;
          D.32378 = sp + 8;
          D.32379 = *D.32378;
          D.32380 = D.32379->dreg;
          store->sreg1 = D.32380;
          D.31240 = *sp;
          D.31422 = D.31240->dreg;
          store->dreg = D.31422;
          D.36257 = (long int) foffset;
          store->data.op[0].const_val = D.36257;
          D.36116 = field->type;
          type_to_eval_stack_type (cfg, D.36116, store);
          D.36116 = field->type;
          D.36258 = mono_class_from_mono_type (D.36116);
          store->klass = D.36258;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.36259>; else goto <D.36260>;
          <D.36259>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = store;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          store->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = store;
          goto <D.36261>;
          <D.36260>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = store;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.36261>:
          <D.36254>:
          D.31240 = *sp;
          D.32926 = D.31240->opcode;
          if (D.32926 != 314) goto <D.36262>; else goto <D.36263>;
          <D.36262>:
          D.36264 = store->flags;
          D.36265 = D.36264 | 32;
          store->flags = D.36265;
          <D.36263>:
          D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.33278 = D.30634 & 8;
          if (D.33278 != 0) goto <D.36268>; else goto <D.36269>;
          <D.36268>:
          D.36116 = field->type;
          D.36270 = mini_type_to_stind (cfg, D.36116);
          if (D.36270 == 81) goto <D.36271>; else goto <D.36272>;
          <D.36271>:
          D.32378 = sp + 8;
          D.32379 = *D.32378;
          D.34346 = D.32379->opcode;
          if (D.34346 != 363) goto <D.36266>; else goto <D.36273>;
          <D.36273>:
          D.32378 = sp + 8;
          D.32379 = *D.32378;
          D.34371 = D.32379->data.op[0].const_val;
          if (D.34371 != 0) goto <D.36266>; else goto <D.36267>;
          <D.36266>:
          {
            struct MonoInst * ptr;
            int dreg;

            D.36274 = alloc_ireg_mp (cfg);
            dreg = (int) D.36274;
            D.30241 = cfg->mempool;
            ptr = mono_mempool_alloc (D.30241, 80);
            ptr->data.op[1].const_val = 0;
            D.36275 = ptr->data.op[1].const_val;
            ptr->data.op[0].const_val = D.36275;
            ptr->prev = 0B;
            D.36276 = ptr->prev;
            ptr->next = D.36276;
            ptr->opcode = 538;
            ptr->flags = 0;
            ptr->type = 0;
            ptr->dreg = -1;
            ptr->sreg3 = -1;
            D.36277 = ptr->sreg3;
            ptr->sreg2 = D.36277;
            D.36278 = ptr->sreg2;
            ptr->sreg1 = D.36278;
            D.30461 = cfg->ip;
            ptr->cil_code = D.30461;
            ptr->dreg = dreg;
            D.31240 = *sp;
            D.31422 = D.31240->dreg;
            ptr->sreg1 = D.31422;
            D.36257 = (long int) foffset;
            ptr->data.op[1].const_val = D.36257;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.36279>; else goto <D.36280>;
            <D.36279>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = ptr;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            ptr->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ptr;
            goto <D.36281>;
            <D.36280>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ptr;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.36281>:
            D.32378 = sp + 8;
            D.32379 = *D.32378;
            emit_write_barrier (cfg, ptr, D.32379);
          }
          <D.36267>:
          <D.36272>:
          <D.36269>:
          D.36264 = store->flags;
          D.34312 = (unsigned char) ins_flag;
          D.36282 = D.36264 | D.34312;
          store->flags = D.36282;
        }
        <D.36144>:
        ins_flag = 0;
        ip = ip + 5;
        goto <D.27394>;
        <D.36130>:
        if (is_instance != 0) goto <D.36287>; else goto <D.36283>;
        <D.36287>:
        klass.144 = klass;
        D.35477 = BIT_FIELD_REF <*klass.144, 64, 256>;
        D.35478 = D.35477 & 2199023255552;
        if (D.35478 != 0) goto <D.36288>; else goto <D.36284>;
        <D.36288>:
        D.30211 = cfg->method;
        D.36289 = mono_method_signature (D.30211);
        D.36290 = BIT_FIELD_REF <*D.36289, 64, 64>;
        D.36291 = D.36290 & 512;
        if (D.36291 == 0) goto <D.36285>; else goto <D.36292>;
        <D.36292>:
        D.31240 = *sp;
        D.32926 = D.31240->opcode;
        if (D.32926 != 424) goto <D.36285>; else goto <D.36293>;
        <D.36293>:
        D.31240 = *sp;
        D.36151 = D.31240->sreg1;
        D.30842 = cfg->args;
        D.30843 = *D.30842;
        D.30857 = D.30843->dreg;
        if (D.36151 != D.30857) goto <D.36285>; else goto <D.36284>;
        <D.36284>:
        klass.144 = klass;
        D.35477 = BIT_FIELD_REF <*klass.144, 64, 256>;
        D.36152 = D.35477 & 1099511627776;
        if (D.36152 != 0) goto <D.36285>; else goto <D.36294>;
        <D.36294>:
        D.36154 = mono_defaults.marshalbyrefobject_class;
        klass.144 = klass;
        if (D.36154 == klass.144) goto <D.36285>; else goto <D.36283>;
        <D.36285>:
        {
          struct MonoMethod * wrapper;
          struct MonoInst * iargs[4];

          try
            {
              if (op == 124) goto <D.36296>; else goto <D.36297>;
              <D.36296>:
              D.36116 = field->type;
              iftmp.208 = mono_marshal_get_ldflda_wrapper (D.36116);
              goto <D.36298>;
              <D.36297>:
              D.36116 = field->type;
              iftmp.208 = mono_marshal_get_ldfld_wrapper (D.36116);
              <D.36298>:
              wrapper = iftmp.208;
              D.30389 = cfg->gsharedvt;
              if (D.30389 != 0) goto <D.36299>; else goto <D.36300>;
              <D.36299>:
              D.30178 = method->klass;
              D.31934 = D.30178->name_space;
              D.30178 = method->klass;
              D.31935 = D.30178->name;
              D.31936 = method->name;
              D.31937 = method->signature;
              D.31938 = D.31937->param_count;
              D.31939 = (int) D.31938;
              D.36301 = mono_opcode_name (op);
              D.36302 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.31934, D.31935, D.31936, D.31939, D.36301, "method-to-ir.c", 10000);
              cfg->exception_message = D.36302;
              D.30322 = cfg->verbose_level;
              if (D.30322 > 1) goto <D.36303>; else goto <D.36304>;
              <D.36303>:
              D.31944 = cfg->exception_message;
              printf ("%s\n", D.31944);
              <D.36304>:
              mono_cfg_set_exception (cfg, 11);
              goto exception_exit;
              <D.36300>:
              D.31240 = *sp;
              iargs[0] = D.31240;
              D.30241 = cfg->mempool;
              D.36305 = mono_mempool_alloc (D.30241, 80);
              iargs[1] = D.36305;
              D.36306 = iargs[1];
              D.36306 = iargs[1];
              D.36306->data.op[1].const_val = 0;
              D.36307 = D.36306->data.op[1].const_val;
              D.36306->data.op[0].const_val = D.36307;
              D.36306 = iargs[1];
              D.36306 = iargs[1];
              D.36306->prev = 0B;
              D.36308 = D.36306->prev;
              D.36306->next = D.36308;
              D.36306 = iargs[1];
              D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.30635 = D.30634 & 33554432;
              if (D.30635 != 0) goto <D.36310>; else goto <D.36311>;
              <D.36310>:
              iftmp.209 = 732;
              goto <D.36312>;
              <D.36311>:
              iftmp.209 = 363;
              <D.36312>:
              D.36306->opcode = iftmp.209;
              D.36306 = iargs[1];
              D.36306->flags = 0;
              D.36306 = iargs[1];
              D.36306->type = 0;
              D.36306 = iargs[1];
              D.36306->dreg = -1;
              D.36306 = iargs[1];
              D.36306 = iargs[1];
              D.36306 = iargs[1];
              D.36306->sreg3 = -1;
              D.36313 = D.36306->sreg3;
              D.36306->sreg2 = D.36313;
              D.36314 = D.36306->sreg2;
              D.36306->sreg1 = D.36314;
              D.36306 = iargs[1];
              D.30461 = cfg->ip;
              D.36306->cil_code = D.30461;
              D.36306 = iargs[1];
              klass.144 = klass;
              D.36306->data.op[0].p = klass.144;
              D.36306 = iargs[1];
              D.36306->data.op[1].src = 11B;
              D.36306 = iargs[1];
              D.36306->type = 3;
              D.36306 = iargs[1];
              D.36315 = alloc_dreg (cfg, 3);
              D.36316 = (int) D.36315;
              D.36306->dreg = D.36316;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.36317>; else goto <D.36318>;
              <D.36317>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36306 = iargs[1];
              D.30490->next = D.36306;
              D.36306 = iargs[1];
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36306->prev = D.30490;
              bblock.106 = cfg->cbb;
              D.36306 = iargs[1];
              bblock.106->last_ins = D.36306;
              goto <D.36319>;
              <D.36318>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              D.36306 = iargs[1];
              bblock.106->last_ins = D.36306;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.36319>:
              D.30241 = cfg->mempool;
              D.36320 = mono_mempool_alloc (D.30241, 80);
              iargs[2] = D.36320;
              D.36321 = iargs[2];
              D.36321 = iargs[2];
              D.36321->data.op[1].const_val = 0;
              D.36322 = D.36321->data.op[1].const_val;
              D.36321->data.op[0].const_val = D.36322;
              D.36321 = iargs[2];
              D.36321 = iargs[2];
              D.36321->prev = 0B;
              D.36323 = D.36321->prev;
              D.36321->next = D.36323;
              D.36321 = iargs[2];
              D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.30635 = D.30634 & 33554432;
              if (D.30635 != 0) goto <D.36325>; else goto <D.36326>;
              <D.36325>:
              iftmp.210 = 732;
              goto <D.36327>;
              <D.36326>:
              iftmp.210 = 363;
              <D.36327>:
              D.36321->opcode = iftmp.210;
              D.36321 = iargs[2];
              D.36321->flags = 0;
              D.36321 = iargs[2];
              D.36321->type = 0;
              D.36321 = iargs[2];
              D.36321->dreg = -1;
              D.36321 = iargs[2];
              D.36321 = iargs[2];
              D.36321 = iargs[2];
              D.36321->sreg3 = -1;
              D.36328 = D.36321->sreg3;
              D.36321->sreg2 = D.36328;
              D.36329 = D.36321->sreg2;
              D.36321->sreg1 = D.36329;
              D.36321 = iargs[2];
              D.30461 = cfg->ip;
              D.36321->cil_code = D.30461;
              D.36321 = iargs[2];
              D.36321->data.op[0].p = field;
              D.36321 = iargs[2];
              D.36321->data.op[1].src = 13B;
              D.36321 = iargs[2];
              D.36321->type = 3;
              D.36321 = iargs[2];
              D.36330 = alloc_dreg (cfg, 3);
              D.36331 = (int) D.36330;
              D.36321->dreg = D.36331;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.36332>; else goto <D.36333>;
              <D.36332>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36321 = iargs[2];
              D.30490->next = D.36321;
              D.36321 = iargs[2];
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36321->prev = D.30490;
              bblock.106 = cfg->cbb;
              D.36321 = iargs[2];
              bblock.106->last_ins = D.36321;
              goto <D.36334>;
              <D.36333>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              D.36321 = iargs[2];
              bblock.106->last_ins = D.36321;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.36334>:
              D.30241 = cfg->mempool;
              D.36335 = mono_mempool_alloc (D.30241, 80);
              iargs[3] = D.36335;
              D.36336 = iargs[3];
              D.36336 = iargs[3];
              D.36336->data.op[1].const_val = 0;
              D.36337 = D.36336->data.op[1].const_val;
              D.36336->data.op[0].const_val = D.36337;
              D.36336 = iargs[3];
              D.36336 = iargs[3];
              D.36336->prev = 0B;
              D.36338 = D.36336->prev;
              D.36336->next = D.36338;
              D.36336 = iargs[3];
              D.36336->opcode = 362;
              D.36336 = iargs[3];
              D.36336->flags = 0;
              D.36336 = iargs[3];
              D.36336->type = 0;
              D.36336 = iargs[3];
              D.36336->dreg = -1;
              D.36336 = iargs[3];
              D.36336 = iargs[3];
              D.36336 = iargs[3];
              D.36336->sreg3 = -1;
              D.36339 = D.36336->sreg3;
              D.36336->sreg2 = D.36339;
              D.36340 = D.36336->sreg2;
              D.36336->sreg1 = D.36340;
              D.36336 = iargs[3];
              D.30461 = cfg->ip;
              D.36336->cil_code = D.30461;
              D.36336 = iargs[3];
              klass.144 = klass;
              D.35477 = BIT_FIELD_REF <*klass.144, 64, 256>;
              D.36123 = D.35477 & 1152921504606846976;
              if (D.36123 != 0) goto <D.36342>; else goto <D.36343>;
              <D.36342>:
              D.36126 = field->offset;
              D.36200 = (long unsigned int) D.36126;
              D.36201 = D.36200 + 18446744073709551600;
              iftmp.211 = (mgreg_t) D.36201;
              goto <D.36344>;
              <D.36343>:
              D.36126 = field->offset;
              iftmp.211 = (mgreg_t) D.36126;
              <D.36344>:
              D.36336->data.op[0].const_val = iftmp.211;
              D.36336 = iargs[3];
              D.36336->type = 1;
              D.36336 = iargs[3];
              D.36345 = alloc_dreg (cfg, 1);
              D.36346 = (int) D.36345;
              D.36336->dreg = D.36346;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.36347>; else goto <D.36348>;
              <D.36347>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36336 = iargs[3];
              D.30490->next = D.36336;
              D.36336 = iargs[3];
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36336->prev = D.30490;
              bblock.106 = cfg->cbb;
              D.36336 = iargs[3];
              bblock.106->last_ins = D.36336;
              goto <D.36349>;
              <D.36348>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              D.36336 = iargs[3];
              bblock.106->last_ins = D.36336;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.36349>:
              D.30632 = cfg->opt;
              D.32993 = D.30632 & 4;
              if (D.32993 != 0) goto <D.36350>; else goto <D.36353>;
              <D.36353>:
              D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.30635 = D.30634 & 33554432;
              if (D.30635 != 0) goto <D.36350>; else goto <D.36351>;
              <D.36350>:
              D.36354 = mono_method_signature (wrapper);
              D.30408 = cfg->real_offset;
              costs = inline_method (cfg, wrapper, D.36354, &iargs, ip, D.30408, dont_inline, 1);
              D.30793 = cfg->exception_type;
              if (D.30793 != 0) goto exception_exit; else goto <D.36355>;
              <D.36355>:
              bblock.106 = cfg->cbb;
              bblock = bblock.106;
              D.36214 = costs <= 0;
              D.36215 = (long int) D.36214;
              D.36216 = __builtin_expect (D.36215, 0);
              if (D.36216 != 0) goto <D.36356>; else goto <D.36357>;
              <D.36356>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10011, "costs > 0");
              <D.36357>:
              D.30408 = cfg->real_offset;
              D.33020 = D.30408 + 5;
              cfg->real_offset = D.33020;
              sp.212 = sp;
              sp = sp.212 + 8;
              D.36359 = iargs[0];
              *sp.212 = D.36359;
              inline_costs = inline_costs + costs;
              goto <D.36352>;
              <D.36351>:
              ins = mono_emit_method_call (cfg, wrapper, &iargs, 0B);
              sp.213 = sp;
              sp = sp.213 + 8;
              *sp.213 = ins;
              <D.36352>:
            }
          finally
            {
              iargs = {CLOBBER};
            }
        }
        goto <D.36286>;
        <D.36283>:
        if (is_instance != 0) goto <D.36361>; else goto <D.36362>;
        <D.36361>:
        D.31240 = *sp;
        D.32922 = D.31240->type;
        if (D.32922 == 7) goto <D.36363>; else goto <D.36364>;
        <D.36363>:
        {
          struct MonoInst * var;

          D.31240 = *sp;
          D.31422 = D.31240->dreg;
          D.36366 = (unsigned int) D.31422;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.36366 < D.31341) goto <D.36367>; else goto <D.36368>;
          <D.36367>:
          D.31344 = cfg->vreg_to_inst;
          D.31240 = *sp;
          D.31422 = D.31240->dreg;
          D.36369 = (long unsigned int) D.31422;
          D.36370 = D.36369 * 8;
          D.36371 = D.31344 + D.36370;
          iftmp.214 = *D.36371;
          goto <D.36372>;
          <D.36368>:
          iftmp.214 = 0B;
          <D.36372>:
          var = iftmp.214;
          if (var == 0B) goto <D.36373>; else goto <D.36374>;
          <D.36373>:
          klass.144 = klass;
          D.34771 = &klass.144->byval_arg;
          D.31240 = *sp;
          D.31422 = D.31240->dreg;
          var = mono_compile_create_var_for_vreg (cfg, D.34771, 329, D.31422);
          goto <D.36375>;
          <D.36374>:
          D.36376 = var->klass;
          klass.144 = klass;
          D.36377 = D.36376 != klass.144;
          D.36378 = (long int) D.36377;
          D.36379 = __builtin_expect (D.36378, 0);
          if (D.36379 != 0) goto <D.36380>; else goto <D.36381>;
          <D.36380>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10034, "var->klass == klass");
          <D.36381>:
          <D.36375>:
          D.30241 = cfg->mempool;
          ins = mono_mempool_alloc (D.30241, 80);
          ins->data.op[1].const_val = 0;
          D.30457 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.30457;
          ins->prev = 0B;
          D.30458 = ins->prev;
          ins->next = D.30458;
          ins->opcode = 314;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.30459 = ins->sreg3;
          ins->sreg2 = D.30459;
          D.30460 = ins->sreg2;
          ins->sreg1 = D.30460;
          D.30461 = cfg->ip;
          ins->cil_code = D.30461;
          ins->data.op[0].p = var;
          D.36382 = var->flags;
          D.36383 = D.36382 | 16;
          var->flags = D.36383;
          ins->type = 5;
          D.36376 = var->klass;
          ins->klass = D.36376;
          D.36384 = alloc_dreg (cfg, 5);
          D.36385 = (int) D.36384;
          ins->dreg = D.36385;
          cfg->has_indirection = 1;
          D.30389 = cfg->gsharedvt;
          D.31326 = D.30389 != 0;
          D.31327 = (long int) D.31326;
          D.31328 = __builtin_expect (D.31327, 0);
          if (D.31328 != 0) goto <D.36386>; else goto <D.36387>;
          <D.36386>:
          D.36388 = var->data.op[1].vtype;
          D.36389 = mini_is_gsharedvt_variable_type (cfg, D.36388);
          if (D.36389 != 0) goto <D.36390>; else goto <D.36391>;
          <D.36390>:
          handle_gsharedvt_ldaddr (cfg);
          <D.36391>:
          <D.36387>:
          if (0 != 0) goto <D.36392>; else goto <D.36393>;
          <D.36392>:
          {
            struct MonoInst * var1;
            struct MonoInst * var2;

            D.36395 = var->dreg;
            D.36396 = D.36395 + 1;
            D.36397 = (unsigned int) D.36396;
            D.31341 = cfg->vreg_to_inst_len;
            if (D.36397 < D.31341) goto <D.36398>; else goto <D.36399>;
            <D.36398>:
            D.31344 = cfg->vreg_to_inst;
            D.36395 = var->dreg;
            D.36400 = (sizetype) D.36395;
            D.36401 = D.36400 + 1;
            D.36402 = D.36401 * 8;
            D.36403 = D.31344 + D.36402;
            iftmp.215 = *D.36403;
            goto <D.36404>;
            <D.36399>:
            iftmp.215 = 0B;
            <D.36404>:
            var1 = iftmp.215;
            D.36395 = var->dreg;
            D.36406 = D.36395 + 2;
            D.36407 = (unsigned int) D.36406;
            D.31341 = cfg->vreg_to_inst_len;
            if (D.36407 < D.31341) goto <D.36408>; else goto <D.36409>;
            <D.36408>:
            D.31344 = cfg->vreg_to_inst;
            D.36395 = var->dreg;
            D.36400 = (sizetype) D.36395;
            D.36410 = D.36400 + 2;
            D.36411 = D.36410 * 8;
            D.36412 = D.31344 + D.36411;
            iftmp.216 = *D.36412;
            goto <D.36413>;
            <D.36409>:
            iftmp.216 = 0B;
            <D.36413>:
            var2 = iftmp.216;
            D.36414 = var1 == 0B;
            D.36415 = (long int) D.36414;
            D.36416 = __builtin_expect (D.36415, 0);
            if (D.36416 != 0) goto <D.36417>; else goto <D.36418>;
            <D.36417>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10036, "var1");
            <D.36418>:
            D.36419 = var2 == 0B;
            D.36420 = (long int) D.36419;
            D.36421 = __builtin_expect (D.36420, 0);
            if (D.36421 != 0) goto <D.36422>; else goto <D.36423>;
            <D.36422>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10036, "var2");
            <D.36423>:
            D.36424 = var1->flags;
            D.36425 = D.36424 | 16;
            var1->flags = D.36425;
            D.36426 = var2->flags;
            D.36427 = D.36426 | 16;
            var2->flags = D.36427;
          }
          <D.36393>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.36428>; else goto <D.36429>;
          <D.36428>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = ins;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          ins->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          goto <D.36430>;
          <D.36429>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.36430>:
          *sp = ins;
        }
        <D.36364>:
        if (op == 124) goto <D.36431>; else goto <D.36432>;
        <D.36431>:
        D.36433 = is_magic_tls_access (field);
        if (D.36433 != 0) goto <D.36434>; else goto <D.36435>;
        <D.36434>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.36436>; else goto <D.36437>;
        <D.36436>:
        D.30178 = method->klass;
        D.31934 = D.30178->name_space;
        D.30178 = method->klass;
        D.31935 = D.30178->name;
        D.31936 = method->name;
        D.31937 = method->signature;
        D.31938 = D.31937->param_count;
        D.31939 = (int) D.31938;
        D.31121 = *ip;
        D.31122 = (int) D.31121;
        D.36438 = mono_opcode_name (D.31122);
        D.36439 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.31934, D.31935, D.31936, D.31939, D.36438, "method-to-ir.c", 10042);
        cfg->exception_message = D.36439;
        D.30322 = cfg->verbose_level;
        if (D.30322 > 1) goto <D.36440>; else goto <D.36441>;
        <D.36440>:
        D.31944 = cfg->exception_message;
        printf ("%s\n", D.31944);
        <D.36441>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.36437>:
        ins = *sp;
        sp.217 = sp;
        sp = sp.217 + 8;
        D.36443 = create_magic_tls_access (cfg, field, &cached_tls_addr, ins);
        *sp.217 = D.36443;
        goto <D.36444>;
        <D.36435>:
        D.31240 = *sp;
        D.32922 = D.31240->type;
        if (D.32922 == 6) goto <D.36445>; else goto <D.36446>;
        <D.36445>:
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.36447 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.36447;
          inst->prev = 0B;
          D.36448 = inst->prev;
          inst->next = D.36448;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.36449 = inst->sreg3;
          inst->sreg2 = D.36449;
          D.36450 = inst->sreg2;
          inst->sreg1 = D.36450;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          inst->dreg = -1;
          D.31240 = *sp;
          D.31422 = D.31240->dreg;
          inst->sreg1 = D.31422;
          inst->data.op[1].const_val = 0;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.36451>; else goto <D.36452>;
          <D.36451>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.36453>;
          <D.36452>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.36453>:
        }
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.36454 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.36454;
          inst->prev = 0B;
          D.36455 = inst->prev;
          inst->next = D.36455;
          inst->opcode = 451;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.36456 = inst->sreg3;
          inst->sreg2 = D.36456;
          D.36457 = inst->sreg2;
          inst->sreg1 = D.36457;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          inst->data.op[1].p = "NullReferenceException";
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.36458>; else goto <D.36459>;
          <D.36458>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.36460>;
          <D.36459>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.36460>:
        }
        <D.36446>:
        D.36461 = alloc_ireg_mp (cfg);
        dreg = (int) D.36461;
        klass.144 = klass;
        D.36462 = mini_is_gsharedvt_klass (cfg, klass.144);
        if (D.36462 != 0) goto <D.36463>; else goto <D.36464>;
        <D.36463>:
        {
          struct MonoInst * offset_ins;

          offset_ins = emit_get_gsharedvt_info (cfg, field, 15);
          D.30241 = cfg->mempool;
          ins = mono_mempool_alloc (D.30241, 80);
          ins->data.op[1].const_val = 0;
          D.30457 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.30457;
          ins->prev = 0B;
          D.30458 = ins->prev;
          ins->next = D.30458;
          ins->opcode = 479;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.30459 = ins->sreg3;
          ins->sreg2 = D.30459;
          D.30460 = ins->sreg2;
          ins->sreg1 = D.30460;
          D.30461 = cfg->ip;
          ins->cil_code = D.30461;
          ins->dreg = dreg;
          D.31240 = *sp;
          D.31422 = D.31240->dreg;
          ins->sreg1 = D.31422;
          D.36465 = offset_ins->dreg;
          ins->sreg2 = D.36465;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.36466>; else goto <D.36467>;
          <D.36466>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = ins;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          ins->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          goto <D.36468>;
          <D.36467>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.36468>:
        }
        goto <D.36469>;
        <D.36464>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 538;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        ins->dreg = dreg;
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        ins->sreg1 = D.31422;
        D.36257 = (long int) foffset;
        ins->data.op[1].const_val = D.36257;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.36470>; else goto <D.36471>;
        <D.36470>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.36472>;
        <D.36471>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.36472>:
        <D.36469>:
        D.36116 = field->type;
        D.36473 = mono_class_from_mono_type (D.36116);
        ins->klass = D.36473;
        ins->type = 5;
        sp.218 = sp;
        sp = sp.218 + 8;
        *sp.218 = ins;
        <D.36444>:
        goto <D.36475>;
        <D.36432>:
        {
          struct MonoInst * load;

          D.30229 = BIT_FIELD_REF <*cfg, 64, 5632>;
          D.30870 = D.30229 & 144115188075855872;
          if (D.30870 != 0) goto <D.36476>; else goto <D.36477>;
          <D.36476>:
          {
            struct MonoInst * inst;

            D.30241 = cfg->mempool;
            inst = mono_mempool_alloc (D.30241, 80);
            inst->data.op[1].const_val = 0;
            D.36478 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.36478;
            inst->prev = 0B;
            D.36479 = inst->prev;
            inst->next = D.36479;
            inst->opcode = 323;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.36480 = inst->sreg3;
            inst->sreg2 = D.36480;
            D.36481 = inst->sreg2;
            inst->sreg1 = D.36481;
            D.30461 = cfg->ip;
            inst->cil_code = D.30461;
            inst->dreg = -1;
            D.31240 = *sp;
            D.31422 = D.31240->dreg;
            inst->sreg1 = D.31422;
            inst->data.op[1].const_val = 0;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.36482>; else goto <D.36483>;
            <D.36482>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = inst;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            inst->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            goto <D.36484>;
            <D.36483>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.36484>:
          }
          {
            struct MonoInst * inst;

            D.30241 = cfg->mempool;
            inst = mono_mempool_alloc (D.30241, 80);
            inst->data.op[1].const_val = 0;
            D.36485 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.36485;
            inst->prev = 0B;
            D.36486 = inst->prev;
            inst->next = D.36486;
            inst->opcode = 451;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.36487 = inst->sreg3;
            inst->sreg2 = D.36487;
            D.36488 = inst->sreg2;
            inst->sreg1 = D.36488;
            D.30461 = cfg->ip;
            inst->cil_code = D.30461;
            inst->data.op[1].p = "NullReferenceException";
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.36489>; else goto <D.36490>;
            <D.36489>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = inst;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            inst->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            goto <D.36491>;
            <D.36490>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.36491>:
          }
          goto <D.36492>;
          <D.36477>:
          <D.36492>:
          klass.144 = klass;
          D.36493 = mini_is_gsharedvt_klass (cfg, klass.144);
          if (D.36493 != 0) goto <D.36494>; else goto <D.36495>;
          <D.36494>:
          {
            struct MonoInst * offset_ins;

            offset_ins = emit_get_gsharedvt_info (cfg, field, 15);
            D.36496 = alloc_ireg_mp (cfg);
            dreg = (int) D.36496;
            D.30241 = cfg->mempool;
            ins = mono_mempool_alloc (D.30241, 80);
            ins->data.op[1].const_val = 0;
            D.30457 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.30457;
            ins->prev = 0B;
            D.30458 = ins->prev;
            ins->next = D.30458;
            ins->opcode = 479;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.30459 = ins->sreg3;
            ins->sreg2 = D.30459;
            D.30460 = ins->sreg2;
            ins->sreg1 = D.30460;
            D.30461 = cfg->ip;
            ins->cil_code = D.30461;
            ins->dreg = dreg;
            D.31240 = *sp;
            D.31422 = D.31240->dreg;
            ins->sreg1 = D.31422;
            D.36497 = offset_ins->dreg;
            ins->sreg2 = D.36497;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.36498>; else goto <D.36499>;
            <D.36498>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = ins;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            ins->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            goto <D.36500>;
            <D.36499>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.36500>:
            D.30241 = cfg->mempool;
            load = mono_mempool_alloc (D.30241, 80);
            load->data.op[1].const_val = 0;
            D.36501 = load->data.op[1].const_val;
            load->data.op[0].const_val = D.36501;
            load->prev = 0B;
            D.36502 = load->prev;
            load->next = D.36502;
            D.36116 = field->type;
            D.36503 = mono_type_to_load_membase (cfg, D.36116);
            D.36504 = (short unsigned int) D.36503;
            load->opcode = D.36504;
            load->flags = 0;
            load->type = 0;
            load->dreg = -1;
            load->sreg3 = -1;
            D.36505 = load->sreg3;
            load->sreg2 = D.36505;
            D.36506 = load->sreg2;
            load->sreg1 = D.36506;
            D.30461 = cfg->ip;
            load->cil_code = D.30461;
            load->dreg = 0;
            load->sreg1 = dreg;
            load->data.op[0].const_val = 0;
            load->type = 1;
            D.36116 = field->type;
            type_to_eval_stack_type (cfg, D.36116, load);
            D.36507 = load->type;
            D.36508 = (<unnamed type>) D.36507;
            D.36509 = alloc_dreg (cfg, D.36508);
            D.36510 = (int) D.36509;
            load->dreg = D.36510;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.36511>; else goto <D.36512>;
            <D.36511>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = load;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            load->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = load;
            goto <D.36513>;
            <D.36512>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = load;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.36513>:
          }
          goto <D.36514>;
          <D.36495>:
          D.30241 = cfg->mempool;
          load = mono_mempool_alloc (D.30241, 80);
          load->data.op[1].const_val = 0;
          D.36501 = load->data.op[1].const_val;
          load->data.op[0].const_val = D.36501;
          load->prev = 0B;
          D.36502 = load->prev;
          load->next = D.36502;
          D.36116 = field->type;
          D.36515 = mono_type_to_load_membase (cfg, D.36116);
          D.36516 = (short unsigned int) D.36515;
          load->opcode = D.36516;
          load->flags = 0;
          load->type = 0;
          load->dreg = -1;
          load->sreg3 = -1;
          D.36505 = load->sreg3;
          load->sreg2 = D.36505;
          D.36506 = load->sreg2;
          load->sreg1 = D.36506;
          D.30461 = cfg->ip;
          load->cil_code = D.30461;
          load->dreg = 0;
          D.31240 = *sp;
          D.31422 = D.31240->dreg;
          load->sreg1 = D.31422;
          D.36257 = (long int) foffset;
          load->data.op[0].const_val = D.36257;
          load->type = 1;
          D.36116 = field->type;
          type_to_eval_stack_type (cfg, D.36116, load);
          D.36507 = load->type;
          D.36508 = (<unnamed type>) D.36507;
          D.36517 = alloc_dreg (cfg, D.36508);
          D.36518 = (int) D.36517;
          load->dreg = D.36518;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.36519>; else goto <D.36520>;
          <D.36519>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = load;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          load->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = load;
          goto <D.36521>;
          <D.36520>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = load;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.36521>:
          <D.36514>:
          D.36522 = load->flags;
          D.34312 = (unsigned char) ins_flag;
          D.36523 = D.36522 | D.34312;
          load->flags = D.36523;
          D.31240 = *sp;
          D.32926 = D.31240->opcode;
          if (D.32926 != 314) goto <D.36524>; else goto <D.36525>;
          <D.36524>:
          D.36522 = load->flags;
          D.36526 = D.36522 | 32;
          load->flags = D.36526;
          <D.36525>:
          sp.219 = sp;
          sp = sp.219 + 8;
          *sp.219 = load;
        }
        <D.36475>:
        <D.36362>:
        <D.36286>:
        if (is_instance != 0) goto <D.36528>; else goto <D.36529>;
        <D.36528>:
        ins_flag = 0;
        ip = ip + 5;
        goto <D.27394>;
        <D.36529>:
        klass.144 = klass;
        context_used = mini_class_check_context_used (cfg, klass.144);
        ftype = mono_field_get_type (field);
        D.36530 = ftype->attrs;
        D.36531 = (int) D.36530;
        D.36532 = D.36531 & 64;
        if (D.36532 != 0) goto <D.36533>; else goto <D.36534>;
        <D.36533>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.36535>; else goto <D.36536>;
        <D.36535>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.36537>; else goto <D.36538>;
        <D.36537>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.36538>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.36536>:
        D.36539 = mini_get_debug_options ();
        D.36540 = D.36539->break_on_unverified;
        if (D.36540 != 0) goto <D.36541>; else goto unverified;
        <D.36541>:
        raise (5);
        <D.36534>:
        if (context_used == 0) goto <D.36542>; else goto <D.36543>;
        <D.36542>:
        D.30632 = cfg->opt;
        D.30633 = D.30632 & 512;
        if (D.30633 == 0) goto <D.36544>; else goto <D.36545>;
        <D.36544>:
        D.30267 = cfg->domain;
        klass.144 = klass;
        mono_class_vtable (D.30267, klass.144);
        klass.144 = klass;
        if (klass.144 == 0B) goto <D.36546>; else goto <D.36548>;
        <D.36548>:
        klass.144 = klass;
        D.34697 = klass.144->exception_type;
        if (D.34697 != 0) goto <D.36546>; else goto <D.36547>;
        <D.36546>:
        klass.144 = klass;
        cfg->exception_ptr = klass.144;
        D.36549 = mini_get_debug_options ();
        D.36550 = D.36549->break_on_unverified;
        if (D.36550 != 0) goto <D.36551>; else goto load_error;
        <D.36551>:
        raise (5);
        <D.36547>:
        <D.36545>:
        <D.36543>:
        {
          int ret;

          D.30267 = cfg->domain;
          D.36552 = &D.30267->lock.mutex;
          ret = pthread_mutex_lock (D.36552);
          if (ret != 0) goto <D.36553>; else goto <D.36554>;
          <D.36553>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.36554>:
          D.36555 = ret != 0;
          D.36556 = (long int) D.36555;
          D.36557 = __builtin_expect (D.36556, 0);
          if (D.36557 != 0) goto <D.36558>; else goto <D.36559>;
          <D.36558>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10119, "ret == 0");
          <D.36559>:
        }
        D.30267 = cfg->domain;
        D.36560 = D.30267->special_static_fields;
        if (D.36560 != 0B) goto <D.36561>; else goto <D.36562>;
        <D.36561>:
        D.30267 = cfg->domain;
        D.36560 = D.30267->special_static_fields;
        addr = monoeg_g_hash_table_lookup (D.36560, field);
        <D.36562>:
        {
          int ret;

          D.30267 = cfg->domain;
          D.36552 = &D.30267->lock.mutex;
          ret = pthread_mutex_unlock (D.36552);
          if (ret != 0) goto <D.36563>; else goto <D.36564>;
          <D.36563>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.36564>:
          D.36565 = ret != 0;
          D.36566 = (long int) D.36565;
          D.36567 = __builtin_expect (D.36566, 0);
          if (D.36567 != 0) goto <D.36568>; else goto <D.36569>;
          <D.36568>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10122, "ret == 0");
          <D.36569>:
        }
        is_special_static = mono_class_field_is_special_static (field);
        if (is_special_static != 0) goto <D.36572>; else goto <D.36570>;
        <D.36572>:
        addr.220 = (long unsigned int) addr;
        D.36574 = addr.220 & 2147483648;
        if (D.36574 == 0) goto <D.36575>; else goto <D.36570>;
        <D.36575>:
        thread_ins = mono_get_thread_intrinsic (cfg);
        goto <D.36571>;
        <D.36570>:
        thread_ins = 0B;
        <D.36571>:
        if (is_special_static != 0) goto <D.36578>; else goto <D.36576>;
        <D.36578>:
        addr.220 = (long unsigned int) addr;
        D.36574 = addr.220 & 2147483648;
        if (D.36574 == 0) goto <D.36579>; else goto <D.36576>;
        <D.36579>:
        if (thread_ins != 0B) goto <D.36580>; else goto <D.36576>;
        <D.36580>:
        D.30632 = cfg->opt;
        D.30633 = D.30632 & 512;
        if (D.30633 == 0) goto <D.36581>; else goto <D.36576>;
        <D.36581>:
        if (context_used == 0) goto <D.36582>; else goto <D.36576>;
        <D.36582>:
        {
          guint32 offset;
          int idx;
          int static_data_reg;
          int array_reg;
          int dreg;

          D.30389 = cfg->gsharedvt;
          if (D.30389 != 0) goto <D.36583>; else goto <D.36584>;
          <D.36583>:
          D.30178 = method->klass;
          D.31934 = D.30178->name_space;
          D.30178 = method->klass;
          D.31935 = D.30178->name;
          D.31936 = method->name;
          D.31937 = method->signature;
          D.31938 = D.31937->param_count;
          D.31939 = (int) D.31938;
          D.36585 = mono_opcode_name (op);
          D.36586 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.31934, D.31935, D.31936, D.31939, D.36585, "method-to-ir.c", 10141);
          cfg->exception_message = D.36586;
          D.30322 = cfg->verbose_level;
          if (D.30322 > 1) goto <D.36587>; else goto <D.36588>;
          <D.36587>:
          D.31944 = cfg->exception_message;
          printf ("%s\n", D.31944);
          <D.36588>:
          mono_cfg_set_exception (cfg, 11);
          goto exception_exit;
          <D.36584>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.36589>; else goto <D.36590>;
          <D.36589>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = thread_ins;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          thread_ins->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = thread_ins;
          goto <D.36591>;
          <D.36590>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = thread_ins;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.36591>:
          D.36592 = alloc_ireg (cfg);
          static_data_reg = (int) D.36592;
          {
            struct MonoInst * inst;

            D.30241 = cfg->mempool;
            inst = mono_mempool_alloc (D.30241, 80);
            inst->data.op[1].const_val = 0;
            D.36593 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.36593;
            inst->prev = 0B;
            D.36594 = inst->prev;
            inst->next = D.36594;
            inst->opcode = 388;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.36595 = inst->sreg3;
            inst->sreg2 = D.36595;
            D.36596 = inst->sreg2;
            inst->sreg1 = D.36596;
            D.30461 = cfg->ip;
            inst->cil_code = D.30461;
            inst->dreg = static_data_reg;
            D.36597 = thread_ins->dreg;
            inst->sreg1 = D.36597;
            inst->data.op[0].const_val = 96;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.36598>; else goto <D.36599>;
            <D.36598>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = inst;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            inst->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            goto <D.36600>;
            <D.36599>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.36600>:
          }
          D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.30635 = D.30634 & 33554432;
          if (D.30635 != 0) goto <D.36601>; else goto <D.36602>;
          <D.36601>:
          {
            int offset_reg;
            int offset2_reg;
            int idx_reg;

            D.30241 = cfg->mempool;
            ins = mono_mempool_alloc (D.30241, 80);
            ins->data.op[1].const_val = 0;
            D.30457 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.30457;
            ins->prev = 0B;
            D.30458 = ins->prev;
            ins->next = D.30458;
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.36604>; else goto <D.36605>;
            <D.36604>:
            iftmp.221 = 732;
            goto <D.36606>;
            <D.36605>:
            iftmp.221 = 363;
            <D.36606>:
            ins->opcode = iftmp.221;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.30459 = ins->sreg3;
            ins->sreg2 = D.30459;
            D.30460 = ins->sreg2;
            ins->sreg1 = D.30460;
            D.30461 = cfg->ip;
            ins->cil_code = D.30461;
            ins->data.op[0].p = field;
            ins->data.op[1].src = 16B;
            ins->type = 3;
            D.36607 = alloc_dreg (cfg, 3);
            D.36608 = (int) D.36607;
            ins->dreg = D.36608;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.36609>; else goto <D.36610>;
            <D.36609>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = ins;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            ins->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            goto <D.36611>;
            <D.36610>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.36611>:
            offset_reg = ins->dreg;
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.36612 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.36612;
              inst->prev = 0B;
              D.36613 = inst->prev;
              inst->next = D.36613;
              inst->opcode = 632;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.36614 = inst->sreg3;
              inst->sreg2 = D.36614;
              D.36615 = inst->sreg2;
              inst->sreg1 = D.36615;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = offset_reg;
              inst->sreg1 = offset_reg;
              inst->data.op[1].const_val = 2147483647;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.36616>; else goto <D.36617>;
              <D.36616>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.36618>;
              <D.36617>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.36618>:
            }
            D.36619 = alloc_ireg (cfg);
            idx_reg = (int) D.36619;
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.36620 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.36620;
              inst->prev = 0B;
              D.36621 = inst->prev;
              inst->next = D.36621;
              inst->opcode = 636;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.36622 = inst->sreg3;
              inst->sreg2 = D.36622;
              D.36623 = inst->sreg2;
              inst->sreg1 = D.36623;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = idx_reg;
              inst->sreg1 = offset_reg;
              inst->data.op[1].const_val = 24;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.36624>; else goto <D.36625>;
              <D.36624>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.36626>;
              <D.36625>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.36626>:
            }
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.36627 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.36627;
              inst->prev = 0B;
              D.36628 = inst->prev;
              inst->next = D.36628;
              inst->opcode = 626;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.36629 = inst->sreg3;
              inst->sreg2 = D.36629;
              D.36630 = inst->sreg2;
              inst->sreg1 = D.36630;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = idx_reg;
              inst->sreg1 = idx_reg;
              inst->data.op[1].const_val = 1;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.36631>; else goto <D.36632>;
              <D.36631>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.36633>;
              <D.36632>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.36633>:
            }
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.36634 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.36634;
              inst->prev = 0B;
              D.36635 = inst->prev;
              inst->next = D.36635;
              inst->opcode = 635;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.36636 = inst->sreg3;
              inst->sreg2 = D.36636;
              D.36637 = inst->sreg2;
              inst->sreg1 = D.36637;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = idx_reg;
              inst->sreg1 = idx_reg;
              inst->data.op[1].const_val = 3;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.36638>; else goto <D.36639>;
              <D.36638>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.36640>;
              <D.36639>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.36640>:
            }
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.36641 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.36641;
              inst->prev = 0B;
              D.36642 = inst->prev;
              inst->next = D.36642;
              inst->opcode = 479;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.36643 = inst->sreg3;
              inst->sreg2 = D.36643;
              D.36644 = inst->sreg2;
              inst->sreg1 = D.36644;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = static_data_reg;
              inst->sreg1 = static_data_reg;
              inst->sreg2 = idx_reg;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.36645>; else goto <D.36646>;
              <D.36645>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.36647>;
              <D.36646>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.36647>:
            }
            D.36648 = alloc_ireg (cfg);
            array_reg = (int) D.36648;
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.36649 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.36649;
              inst->prev = 0B;
              D.36650 = inst->prev;
              inst->next = D.36650;
              inst->opcode = 388;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.36651 = inst->sreg3;
              inst->sreg2 = D.36651;
              D.36652 = inst->sreg2;
              inst->sreg1 = D.36652;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = array_reg;
              inst->sreg1 = static_data_reg;
              inst->data.op[0].const_val = 0;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.36653>; else goto <D.36654>;
              <D.36653>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.36655>;
              <D.36654>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.36655>:
            }
            D.36656 = alloc_ireg (cfg);
            offset2_reg = (int) D.36656;
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.36657 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.36657;
              inst->prev = 0B;
              D.36658 = inst->prev;
              inst->next = D.36658;
              inst->opcode = 632;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.36659 = inst->sreg3;
              inst->sreg2 = D.36659;
              D.36660 = inst->sreg2;
              inst->sreg1 = D.36660;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = offset2_reg;
              inst->sreg1 = offset_reg;
              inst->data.op[1].const_val = 16777215;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.36661>; else goto <D.36662>;
              <D.36661>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.36663>;
              <D.36662>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.36663>:
            }
            D.36664 = alloc_ireg (cfg);
            dreg = (int) D.36664;
            D.30241 = cfg->mempool;
            ins = mono_mempool_alloc (D.30241, 80);
            ins->data.op[1].const_val = 0;
            D.30457 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.30457;
            ins->prev = 0B;
            D.30458 = ins->prev;
            ins->next = D.30458;
            ins->opcode = 479;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.30459 = ins->sreg3;
            ins->sreg2 = D.30459;
            D.30460 = ins->sreg2;
            ins->sreg1 = D.30460;
            D.30461 = cfg->ip;
            ins->cil_code = D.30461;
            ins->dreg = dreg;
            ins->sreg1 = array_reg;
            ins->sreg2 = offset2_reg;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.36665>; else goto <D.36666>;
            <D.36665>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = ins;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            ins->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            goto <D.36667>;
            <D.36666>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.36667>:
          }
          goto <D.36668>;
          <D.36602>:
          addr.222 = (long int) addr;
          D.36670 = (unsigned int) addr.222;
          offset = D.36670 & 2147483647;
          D.36671 = offset >> 24;
          D.36672 = D.36671 + 4294967295;
          idx = (int) D.36672;
          D.36673 = alloc_ireg (cfg);
          array_reg = (int) D.36673;
          {
            struct MonoInst * inst;

            D.30241 = cfg->mempool;
            inst = mono_mempool_alloc (D.30241, 80);
            inst->data.op[1].const_val = 0;
            D.36674 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.36674;
            inst->prev = 0B;
            D.36675 = inst->prev;
            inst->next = D.36675;
            inst->opcode = 388;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.36676 = inst->sreg3;
            inst->sreg2 = D.36676;
            D.36677 = inst->sreg2;
            inst->sreg1 = D.36677;
            D.30461 = cfg->ip;
            inst->cil_code = D.30461;
            inst->dreg = array_reg;
            inst->sreg1 = static_data_reg;
            D.36678 = (long unsigned int) idx;
            D.36679 = D.36678 * 8;
            D.36680 = (long int) D.36679;
            inst->data.op[0].const_val = D.36680;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.36681>; else goto <D.36682>;
            <D.36681>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = inst;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            inst->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            goto <D.36683>;
            <D.36682>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.36683>:
          }
          D.36684 = alloc_ireg (cfg);
          dreg = (int) D.36684;
          D.30241 = cfg->mempool;
          ins = mono_mempool_alloc (D.30241, 80);
          ins->data.op[1].const_val = 0;
          D.30457 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.30457;
          ins->prev = 0B;
          D.30458 = ins->prev;
          ins->next = D.30458;
          ins->opcode = 429;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.30459 = ins->sreg3;
          ins->sreg2 = D.30459;
          D.30460 = ins->sreg2;
          ins->sreg1 = D.30460;
          D.30461 = cfg->ip;
          ins->cil_code = D.30461;
          ins->dreg = dreg;
          ins->sreg1 = array_reg;
          D.36685 = (long int) offset;
          D.36686 = D.36685 & 16777215;
          ins->data.op[1].const_val = D.36686;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.36687>; else goto <D.36688>;
          <D.36687>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = ins;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          ins->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          goto <D.36689>;
          <D.36688>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.36689>:
          <D.36668>:
        }
        goto <D.36577>;
        <D.36576>:
        D.30632 = cfg->opt;
        D.30633 = D.30632 & 512;
        if (D.30633 != 0) goto <D.36690>; else goto <D.36694>;
        <D.36694>:
        D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.30635 = D.30634 & 33554432;
        if (D.30635 != 0) goto <D.36695>; else goto <D.36691>;
        <D.36695>:
        if (is_special_static != 0) goto <D.36690>; else goto <D.36691>;
        <D.36691>:
        if (context_used != 0) goto <D.36696>; else goto <D.36692>;
        <D.36696>:
        if (is_special_static != 0) goto <D.36690>; else goto <D.36692>;
        <D.36690>:
        {
          struct MonoInst * iargs[2];

          try
            {
              klass.203 = field->parent;
              D.36697 = klass.203 == 0B;
              D.36698 = (long int) D.36697;
              D.36699 = __builtin_expect (D.36698, 0);
              if (D.36699 != 0) goto <D.36700>; else goto <D.36701>;
              <D.36700>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10182, "field->parent");
              <D.36701>:
              D.30632 = cfg->opt;
              D.30633 = D.30632 & 512;
              if (D.30633 != 0) goto <D.36702>; else goto <D.36705>;
              <D.36705>:
              D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.30635 = D.30634 & 33554432;
              if (D.30635 != 0) goto <D.36702>; else goto <D.36703>;
              <D.36702>:
              {
                struct MonoInst * __domain_var;

                __domain_var = mono_get_domainvar (cfg);
                D.30241 = cfg->mempool;
                D.36706 = mono_mempool_alloc (D.30241, 80);
                iargs[0] = D.36706;
                D.36707 = iargs[0];
                D.36707 = iargs[0];
                D.36707->data.op[1].const_val = 0;
                D.36708 = D.36707->data.op[1].const_val;
                D.36707->data.op[0].const_val = D.36708;
                D.36707 = iargs[0];
                D.36707 = iargs[0];
                D.36707->prev = 0B;
                D.36709 = D.36707->prev;
                D.36707->next = D.36709;
                D.36707 = iargs[0];
                D.36707->opcode = 424;
                D.36707 = iargs[0];
                D.36707->flags = 0;
                D.36707 = iargs[0];
                D.36707->type = 0;
                D.36707 = iargs[0];
                D.36707->dreg = -1;
                D.36707 = iargs[0];
                D.36707 = iargs[0];
                D.36707 = iargs[0];
                D.36707->sreg3 = -1;
                D.36710 = D.36707->sreg3;
                D.36707->sreg2 = D.36710;
                D.36711 = D.36707->sreg2;
                D.36707->sreg1 = D.36711;
                D.36707 = iargs[0];
                D.30461 = cfg->ip;
                D.36707->cil_code = D.30461;
                D.36707 = iargs[0];
                D.30978 = cfg->varinfo;
                D.36712 = __domain_var->data.op[0].const_val;
                D.36713 = (long unsigned int) D.36712;
                D.36714 = D.36713 * 8;
                D.36715 = D.30978 + D.36714;
                D.36716 = *D.36715;
                D.36717 = D.36716->data.op[1].vtype;
                D.36718 = mono_type_to_regmove (cfg, D.36717);
                D.36719 = (short unsigned int) D.36718;
                D.36707->opcode = D.36719;
                D.30978 = cfg->varinfo;
                D.36712 = __domain_var->data.op[0].const_val;
                D.36713 = (long unsigned int) D.36712;
                D.36714 = D.36713 * 8;
                D.36715 = D.30978 + D.36714;
                D.36716 = *D.36715;
                D.36717 = D.36716->data.op[1].vtype;
                D.36707 = iargs[0];
                type_to_eval_stack_type (cfg, D.36717, D.36707);
                D.36707 = iargs[0];
                D.30978 = cfg->varinfo;
                D.36712 = __domain_var->data.op[0].const_val;
                D.36713 = (long unsigned int) D.36712;
                D.36714 = D.36713 * 8;
                D.36715 = D.30978 + D.36714;
                D.36716 = *D.36715;
                D.36720 = D.36716->klass;
                D.36707->klass = D.36720;
                D.36707 = iargs[0];
                D.30978 = cfg->varinfo;
                D.36712 = __domain_var->data.op[0].const_val;
                D.36713 = (long unsigned int) D.36712;
                D.36714 = D.36713 * 8;
                D.36715 = D.30978 + D.36714;
                D.36716 = *D.36715;
                D.36721 = D.36716->dreg;
                D.36707->sreg1 = D.36721;
                D.36707 = iargs[0];
                D.36707 = iargs[0];
                D.36722 = D.36707->type;
                D.36723 = (<unnamed type>) D.36722;
                D.36724 = alloc_dreg (cfg, D.36723);
                D.36725 = (int) D.36724;
                D.36707->dreg = D.36725;
                D.36707 = iargs[0];
                D.36726 = D.36707->opcode;
                if (D.36726 == 427) goto <D.36727>; else goto <D.36728>;
                <D.36727>:
                D.36707 = iargs[0];
                D.30978 = cfg->varinfo;
                D.36712 = __domain_var->data.op[0].const_val;
                D.36713 = (long unsigned int) D.36712;
                D.36714 = D.36713 * 8;
                D.36715 = D.30978 + D.36714;
                D.36716 = *D.36715;
                D.36717 = D.36716->data.op[1].vtype;
                D.36729 = mono_class_from_mono_type (D.36717);
                D.36707->klass = D.36729;
                <D.36728>:
              }
              goto <D.36704>;
              <D.36703>:
              D.30241 = cfg->mempool;
              D.36730 = mono_mempool_alloc (D.30241, 80);
              iargs[0] = D.36730;
              D.36707 = iargs[0];
              D.36707 = iargs[0];
              D.36707->data.op[1].const_val = 0;
              D.36708 = D.36707->data.op[1].const_val;
              D.36707->data.op[0].const_val = D.36708;
              D.36707 = iargs[0];
              D.36707 = iargs[0];
              D.36707->prev = 0B;
              D.36709 = D.36707->prev;
              D.36707->next = D.36709;
              D.36707 = iargs[0];
              D.36707->opcode = 363;
              D.36707 = iargs[0];
              D.36707->flags = 0;
              D.36707 = iargs[0];
              D.36707->type = 0;
              D.36707 = iargs[0];
              D.36707->dreg = -1;
              D.36707 = iargs[0];
              D.36707 = iargs[0];
              D.36707 = iargs[0];
              D.36707->sreg3 = -1;
              D.36710 = D.36707->sreg3;
              D.36707->sreg2 = D.36710;
              D.36711 = D.36707->sreg2;
              D.36707->sreg1 = D.36711;
              D.36707 = iargs[0];
              D.30461 = cfg->ip;
              D.36707->cil_code = D.30461;
              D.36707 = iargs[0];
              D.30267 = cfg->domain;
              D.36707->data.op[0].p = D.30267;
              D.36707 = iargs[0];
              D.36707->type = 3;
              D.36707 = iargs[0];
              D.36731 = alloc_dreg (cfg, 3);
              D.36732 = (int) D.36731;
              D.36707->dreg = D.36732;
              <D.36704>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.36733>; else goto <D.36734>;
              <D.36733>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36707 = iargs[0];
              D.30490->next = D.36707;
              D.36707 = iargs[0];
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36707->prev = D.30490;
              bblock.106 = cfg->cbb;
              D.36707 = iargs[0];
              bblock.106->last_ins = D.36707;
              goto <D.36735>;
              <D.36734>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              D.36707 = iargs[0];
              bblock.106->last_ins = D.36707;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.36735>:
              if (context_used != 0) goto <D.36736>; else goto <D.36737>;
              <D.36736>:
              D.36738 = emit_get_rgctx_field (cfg, context_used, field, 7);
              iargs[1] = D.36738;
              goto <D.36739>;
              <D.36737>:
              D.30241 = cfg->mempool;
              D.36740 = mono_mempool_alloc (D.30241, 80);
              iargs[1] = D.36740;
              D.36741 = iargs[1];
              D.36741 = iargs[1];
              D.36741->data.op[1].const_val = 0;
              D.36742 = D.36741->data.op[1].const_val;
              D.36741->data.op[0].const_val = D.36742;
              D.36741 = iargs[1];
              D.36741 = iargs[1];
              D.36741->prev = 0B;
              D.36743 = D.36741->prev;
              D.36741->next = D.36743;
              D.36741 = iargs[1];
              D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.30635 = D.30634 & 33554432;
              if (D.30635 != 0) goto <D.36745>; else goto <D.36746>;
              <D.36745>:
              iftmp.223 = 732;
              goto <D.36747>;
              <D.36746>:
              iftmp.223 = 363;
              <D.36747>:
              D.36741->opcode = iftmp.223;
              D.36741 = iargs[1];
              D.36741->flags = 0;
              D.36741 = iargs[1];
              D.36741->type = 0;
              D.36741 = iargs[1];
              D.36741->dreg = -1;
              D.36741 = iargs[1];
              D.36741 = iargs[1];
              D.36741 = iargs[1];
              D.36741->sreg3 = -1;
              D.36748 = D.36741->sreg3;
              D.36741->sreg2 = D.36748;
              D.36749 = D.36741->sreg2;
              D.36741->sreg1 = D.36749;
              D.36741 = iargs[1];
              D.30461 = cfg->ip;
              D.36741->cil_code = D.30461;
              D.36741 = iargs[1];
              D.36741->data.op[0].p = field;
              D.36741 = iargs[1];
              D.36741->data.op[1].src = 13B;
              D.36741 = iargs[1];
              D.36741->type = 3;
              D.36741 = iargs[1];
              D.36750 = alloc_dreg (cfg, 3);
              D.36751 = (int) D.36750;
              D.36741->dreg = D.36751;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.36752>; else goto <D.36753>;
              <D.36752>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36741 = iargs[1];
              D.30490->next = D.36741;
              D.36741 = iargs[1];
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36741->prev = D.30490;
              bblock.106 = cfg->cbb;
              D.36741 = iargs[1];
              bblock.106->last_ins = D.36741;
              goto <D.36754>;
              <D.36753>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              D.36741 = iargs[1];
              bblock.106->last_ins = D.36741;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.36754>:
              <D.36739>:
              ins = mono_emit_jit_icall (cfg, mono_class_static_field_address, &iargs);
            }
          finally
            {
              iargs = {CLOBBER};
            }
        }
        goto <D.36693>;
        <D.36692>:
        if (context_used != 0) goto <D.36755>; else goto <D.36756>;
        <D.36755>:
        {
          struct MonoInst * static_data;

          klass.144 = klass;
          D.36757 = mono_class_needs_cctor_run (klass.144, method);
          if (D.36757 != 0) goto <D.36758>; else goto <D.36759>;
          <D.36758>:
          klass.144 = klass;
          emit_generic_class_init (cfg, klass.144);
          <D.36759>:
          klass.144 = klass;
          static_data = emit_get_rgctx_klass (cfg, context_used, klass.144, 0);
          klass.144 = klass;
          D.36760 = mini_is_gsharedvt_klass (cfg, klass.144);
          if (D.36760 != 0) goto <D.36761>; else goto <D.36762>;
          <D.36761>:
          {
            struct MonoInst * offset_ins;

            offset_ins = emit_get_rgctx_field (cfg, context_used, field, 15);
            D.36763 = alloc_ireg_mp (cfg);
            dreg = (int) D.36763;
            D.30241 = cfg->mempool;
            ins = mono_mempool_alloc (D.30241, 80);
            ins->data.op[1].const_val = 0;
            D.30457 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.30457;
            ins->prev = 0B;
            D.30458 = ins->prev;
            ins->next = D.30458;
            ins->opcode = 479;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.30459 = ins->sreg3;
            ins->sreg2 = D.30459;
            D.30460 = ins->sreg2;
            ins->sreg1 = D.30460;
            D.30461 = cfg->ip;
            ins->cil_code = D.30461;
            ins->dreg = dreg;
            D.36764 = static_data->dreg;
            ins->sreg1 = D.36764;
            D.36765 = offset_ins->dreg;
            ins->sreg2 = D.36765;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.36766>; else goto <D.36767>;
            <D.36766>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = ins;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            ins->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            goto <D.36768>;
            <D.36767>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.36768>:
          }
          goto <D.36769>;
          <D.36762>:
          D.36126 = field->offset;
          if (D.36126 == 0) goto <D.36770>; else goto <D.36771>;
          <D.36770>:
          ins = static_data;
          goto <D.36772>;
          <D.36771>:
          {
            int addr_reg;

            D.36773 = mono_alloc_preg (cfg);
            addr_reg = (int) D.36773;
            D.30241 = cfg->mempool;
            ins = mono_mempool_alloc (D.30241, 80);
            ins->data.op[1].const_val = 0;
            D.30457 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.30457;
            ins->prev = 0B;
            D.30458 = ins->prev;
            ins->next = D.30458;
            ins->opcode = 538;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.30459 = ins->sreg3;
            ins->sreg2 = D.30459;
            D.30460 = ins->sreg2;
            ins->sreg1 = D.30460;
            D.30461 = cfg->ip;
            ins->cil_code = D.30461;
            ins->dreg = addr_reg;
            D.36764 = static_data->dreg;
            ins->sreg1 = D.36764;
            D.36126 = field->offset;
            D.36774 = (long int) D.36126;
            ins->data.op[1].const_val = D.36774;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.36775>; else goto <D.36776>;
            <D.36775>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = ins;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            ins->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            goto <D.36777>;
            <D.36776>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.36777>:
          }
          <D.36772>:
          <D.36769>:
        }
        goto <D.36778>;
        <D.36756>:
        D.30632 = cfg->opt;
        D.30633 = D.30632 & 512;
        if (D.30633 != 0) goto <D.36779>; else goto <D.36782>;
        <D.36782>:
        D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.30635 = D.30634 & 33554432;
        if (D.30635 != 0) goto <D.36783>; else goto <D.36780>;
        <D.36783>:
        if (addr != 0B) goto <D.36779>; else goto <D.36780>;
        <D.36779>:
        {
          struct MonoInst * iargs[2];

          try
            {
              klass.203 = field->parent;
              D.36697 = klass.203 == 0B;
              D.36698 = (long int) D.36697;
              D.36699 = __builtin_expect (D.36698, 0);
              if (D.36699 != 0) goto <D.36784>; else goto <D.36785>;
              <D.36784>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10226, "field->parent");
              <D.36785>:
              D.30632 = cfg->opt;
              D.30633 = D.30632 & 512;
              if (D.30633 != 0) goto <D.36786>; else goto <D.36789>;
              <D.36789>:
              D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.30635 = D.30634 & 33554432;
              if (D.30635 != 0) goto <D.36786>; else goto <D.36787>;
              <D.36786>:
              {
                struct MonoInst * __domain_var;

                __domain_var = mono_get_domainvar (cfg);
                D.30241 = cfg->mempool;
                D.36790 = mono_mempool_alloc (D.30241, 80);
                iargs[0] = D.36790;
                D.36791 = iargs[0];
                D.36791 = iargs[0];
                D.36791->data.op[1].const_val = 0;
                D.36792 = D.36791->data.op[1].const_val;
                D.36791->data.op[0].const_val = D.36792;
                D.36791 = iargs[0];
                D.36791 = iargs[0];
                D.36791->prev = 0B;
                D.36793 = D.36791->prev;
                D.36791->next = D.36793;
                D.36791 = iargs[0];
                D.36791->opcode = 424;
                D.36791 = iargs[0];
                D.36791->flags = 0;
                D.36791 = iargs[0];
                D.36791->type = 0;
                D.36791 = iargs[0];
                D.36791->dreg = -1;
                D.36791 = iargs[0];
                D.36791 = iargs[0];
                D.36791 = iargs[0];
                D.36791->sreg3 = -1;
                D.36794 = D.36791->sreg3;
                D.36791->sreg2 = D.36794;
                D.36795 = D.36791->sreg2;
                D.36791->sreg1 = D.36795;
                D.36791 = iargs[0];
                D.30461 = cfg->ip;
                D.36791->cil_code = D.30461;
                D.36791 = iargs[0];
                D.30978 = cfg->varinfo;
                D.36796 = __domain_var->data.op[0].const_val;
                D.36797 = (long unsigned int) D.36796;
                D.36798 = D.36797 * 8;
                D.36799 = D.30978 + D.36798;
                D.36800 = *D.36799;
                D.36801 = D.36800->data.op[1].vtype;
                D.36802 = mono_type_to_regmove (cfg, D.36801);
                D.36803 = (short unsigned int) D.36802;
                D.36791->opcode = D.36803;
                D.30978 = cfg->varinfo;
                D.36796 = __domain_var->data.op[0].const_val;
                D.36797 = (long unsigned int) D.36796;
                D.36798 = D.36797 * 8;
                D.36799 = D.30978 + D.36798;
                D.36800 = *D.36799;
                D.36801 = D.36800->data.op[1].vtype;
                D.36791 = iargs[0];
                type_to_eval_stack_type (cfg, D.36801, D.36791);
                D.36791 = iargs[0];
                D.30978 = cfg->varinfo;
                D.36796 = __domain_var->data.op[0].const_val;
                D.36797 = (long unsigned int) D.36796;
                D.36798 = D.36797 * 8;
                D.36799 = D.30978 + D.36798;
                D.36800 = *D.36799;
                D.36804 = D.36800->klass;
                D.36791->klass = D.36804;
                D.36791 = iargs[0];
                D.30978 = cfg->varinfo;
                D.36796 = __domain_var->data.op[0].const_val;
                D.36797 = (long unsigned int) D.36796;
                D.36798 = D.36797 * 8;
                D.36799 = D.30978 + D.36798;
                D.36800 = *D.36799;
                D.36805 = D.36800->dreg;
                D.36791->sreg1 = D.36805;
                D.36791 = iargs[0];
                D.36791 = iargs[0];
                D.36806 = D.36791->type;
                D.36807 = (<unnamed type>) D.36806;
                D.36808 = alloc_dreg (cfg, D.36807);
                D.36809 = (int) D.36808;
                D.36791->dreg = D.36809;
                D.36791 = iargs[0];
                D.36810 = D.36791->opcode;
                if (D.36810 == 427) goto <D.36811>; else goto <D.36812>;
                <D.36811>:
                D.36791 = iargs[0];
                D.30978 = cfg->varinfo;
                D.36796 = __domain_var->data.op[0].const_val;
                D.36797 = (long unsigned int) D.36796;
                D.36798 = D.36797 * 8;
                D.36799 = D.30978 + D.36798;
                D.36800 = *D.36799;
                D.36801 = D.36800->data.op[1].vtype;
                D.36813 = mono_class_from_mono_type (D.36801);
                D.36791->klass = D.36813;
                <D.36812>:
              }
              goto <D.36788>;
              <D.36787>:
              D.30241 = cfg->mempool;
              D.36814 = mono_mempool_alloc (D.30241, 80);
              iargs[0] = D.36814;
              D.36791 = iargs[0];
              D.36791 = iargs[0];
              D.36791->data.op[1].const_val = 0;
              D.36792 = D.36791->data.op[1].const_val;
              D.36791->data.op[0].const_val = D.36792;
              D.36791 = iargs[0];
              D.36791 = iargs[0];
              D.36791->prev = 0B;
              D.36793 = D.36791->prev;
              D.36791->next = D.36793;
              D.36791 = iargs[0];
              D.36791->opcode = 363;
              D.36791 = iargs[0];
              D.36791->flags = 0;
              D.36791 = iargs[0];
              D.36791->type = 0;
              D.36791 = iargs[0];
              D.36791->dreg = -1;
              D.36791 = iargs[0];
              D.36791 = iargs[0];
              D.36791 = iargs[0];
              D.36791->sreg3 = -1;
              D.36794 = D.36791->sreg3;
              D.36791->sreg2 = D.36794;
              D.36795 = D.36791->sreg2;
              D.36791->sreg1 = D.36795;
              D.36791 = iargs[0];
              D.30461 = cfg->ip;
              D.36791->cil_code = D.30461;
              D.36791 = iargs[0];
              D.30267 = cfg->domain;
              D.36791->data.op[0].p = D.30267;
              D.36791 = iargs[0];
              D.36791->type = 3;
              D.36791 = iargs[0];
              D.36815 = alloc_dreg (cfg, 3);
              D.36816 = (int) D.36815;
              D.36791->dreg = D.36816;
              <D.36788>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.36817>; else goto <D.36818>;
              <D.36817>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36791 = iargs[0];
              D.30490->next = D.36791;
              D.36791 = iargs[0];
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36791->prev = D.30490;
              bblock.106 = cfg->cbb;
              D.36791 = iargs[0];
              bblock.106->last_ins = D.36791;
              goto <D.36819>;
              <D.36818>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              D.36791 = iargs[0];
              bblock.106->last_ins = D.36791;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.36819>:
              D.30241 = cfg->mempool;
              D.36820 = mono_mempool_alloc (D.30241, 80);
              iargs[1] = D.36820;
              D.36821 = iargs[1];
              D.36821 = iargs[1];
              D.36821->data.op[1].const_val = 0;
              D.36822 = D.36821->data.op[1].const_val;
              D.36821->data.op[0].const_val = D.36822;
              D.36821 = iargs[1];
              D.36821 = iargs[1];
              D.36821->prev = 0B;
              D.36823 = D.36821->prev;
              D.36821->next = D.36823;
              D.36821 = iargs[1];
              D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.30635 = D.30634 & 33554432;
              if (D.30635 != 0) goto <D.36825>; else goto <D.36826>;
              <D.36825>:
              iftmp.224 = 732;
              goto <D.36827>;
              <D.36826>:
              iftmp.224 = 363;
              <D.36827>:
              D.36821->opcode = iftmp.224;
              D.36821 = iargs[1];
              D.36821->flags = 0;
              D.36821 = iargs[1];
              D.36821->type = 0;
              D.36821 = iargs[1];
              D.36821->dreg = -1;
              D.36821 = iargs[1];
              D.36821 = iargs[1];
              D.36821 = iargs[1];
              D.36821->sreg3 = -1;
              D.36828 = D.36821->sreg3;
              D.36821->sreg2 = D.36828;
              D.36829 = D.36821->sreg2;
              D.36821->sreg1 = D.36829;
              D.36821 = iargs[1];
              D.30461 = cfg->ip;
              D.36821->cil_code = D.30461;
              D.36821 = iargs[1];
              D.36821->data.op[0].p = field;
              D.36821 = iargs[1];
              D.36821->data.op[1].src = 13B;
              D.36821 = iargs[1];
              D.36821->type = 3;
              D.36821 = iargs[1];
              D.36830 = alloc_dreg (cfg, 3);
              D.36831 = (int) D.36830;
              D.36821->dreg = D.36831;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.36832>; else goto <D.36833>;
              <D.36832>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36821 = iargs[1];
              D.30490->next = D.36821;
              D.36821 = iargs[1];
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.36821->prev = D.30490;
              bblock.106 = cfg->cbb;
              D.36821 = iargs[1];
              bblock.106->last_ins = D.36821;
              goto <D.36834>;
              <D.36833>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              D.36821 = iargs[1];
              bblock.106->last_ins = D.36821;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.36834>:
              ins = mono_emit_jit_icall (cfg, mono_class_static_field_address, &iargs);
            }
          finally
            {
              iargs = {CLOBBER};
            }
        }
        goto <D.36781>;
        <D.36780>:
        {
          struct MonoVTable * vtable;

          vtable = 0B;
          D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.30635 = D.30634 & 33554432;
          if (D.30635 == 0) goto <D.36835>; else goto <D.36836>;
          <D.36835>:
          D.30267 = cfg->domain;
          klass.144 = klass;
          vtable = mono_class_vtable (D.30267, klass.144);
          <D.36836>:
          klass.144 = klass;
          if (klass.144 == 0B) goto <D.36837>; else goto <D.36839>;
          <D.36839>:
          klass.144 = klass;
          D.34697 = klass.144->exception_type;
          if (D.34697 != 0) goto <D.36837>; else goto <D.36838>;
          <D.36837>:
          klass.144 = klass;
          cfg->exception_ptr = klass.144;
          D.36840 = mini_get_debug_options ();
          D.36841 = D.36840->break_on_unverified;
          if (D.36841 != 0) goto <D.36842>; else goto load_error;
          <D.36842>:
          raise (5);
          <D.36838>:
          if (addr == 0B) goto <D.36843>; else goto <D.36844>;
          <D.36843>:
          klass.144 = klass;
          D.36845 = mini_field_access_needs_cctor_run (cfg, method, klass.144, vtable);
          if (D.36845 != 0) goto <D.36846>; else goto <D.36847>;
          <D.36846>:
          klass.144 = klass;
          D.36848 = monoeg_g_slist_find (class_inits, klass.144);
          if (D.36848 == 0B) goto <D.36849>; else goto <D.36850>;
          <D.36849>:
          klass.144 = klass;
          helper_sig_class_init_trampoline.160 = helper_sig_class_init_trampoline;
          mono_emit_abs_call (cfg, 15, klass.144, helper_sig_class_init_trampoline.160, 0B);
          D.30322 = cfg->verbose_level;
          if (D.30322 > 2) goto <D.36851>; else goto <D.36852>;
          <D.36851>:
          klass.144 = klass;
          D.36853 = klass.144->name_space;
          klass.144 = klass;
          D.36854 = klass.144->name;
          D.36855 = mono_field_get_name (field);
          printf ("class %s.%s needs init call for %s\n", D.36853, D.36854, D.36855);
          <D.36852>:
          klass.144 = klass;
          class_inits = monoeg_g_slist_prepend (class_inits, klass.144);
          <D.36850>:
          goto <D.36856>;
          <D.36847>:
          D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.36857 = D.30634 & 134217728;
          if (D.36857 != 0) goto <D.36858>; else goto <D.36859>;
          <D.36858>:
          {
            struct MonoException * ex;

            D.36860 = vtable == 0B;
            D.36861 = (long int) D.36860;
            D.36862 = __builtin_expect (D.36861, 0);
            if (D.36862 != 0) goto <D.36863>; else goto <D.36864>;
            <D.36863>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10251, "vtable");
            <D.36864>:
            D.36865 = BIT_FIELD_REF <*vtable, 64, 320>;
            D.36866 = D.36865 & 274877906944;
            if (D.36866 == 0) goto <D.36867>; else goto <D.36868>;
            <D.36867>:
            D.30211 = cfg->method;
            if (D.30211 != method) goto <D.36869>; else goto <D.36870>;
            <D.36869>:
            D.30183 = BIT_FIELD_REF <*method, 64, 256>;
            D.30184 = D.30183 & 4467570830351532032;
            if (D.30184 == 0) goto <D.36871>; else goto <D.36872>;
            <D.36871>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 1) goto <D.36873>; else goto <D.36874>;
            <D.36873>:
            printf ("inline failed: %s\n", "class init");
            <D.36874>:
            goto inline_failure;
            <D.36872>:
            <D.36870>:
            <D.36868>:
            ex = mono_runtime_class_init_full (vtable, 0);
            if (ex != 0B) goto <D.36875>; else goto <D.36876>;
            <D.36875>:
            set_exception_object (cfg, ex);
            goto exception_exit;
            <D.36876>:
          }
          <D.36859>:
          <D.36856>:
          D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.30635 = D.30634 & 33554432;
          if (D.30635 != 0) goto <D.36877>; else goto <D.36878>;
          <D.36877>:
          D.30241 = cfg->mempool;
          ins = mono_mempool_alloc (D.30241, 80);
          ins->data.op[1].const_val = 0;
          D.30457 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.30457;
          ins->prev = 0B;
          D.30458 = ins->prev;
          ins->next = D.30458;
          D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.30635 = D.30634 & 33554432;
          if (D.30635 != 0) goto <D.36880>; else goto <D.36881>;
          <D.36880>:
          iftmp.225 = 732;
          goto <D.36882>;
          <D.36881>:
          iftmp.225 = 363;
          <D.36882>:
          ins->opcode = iftmp.225;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.30459 = ins->sreg3;
          ins->sreg2 = D.30459;
          D.30460 = ins->sreg2;
          ins->sreg1 = D.30460;
          D.30461 = cfg->ip;
          ins->cil_code = D.30461;
          ins->data.op[0].p = field;
          ins->data.op[1].src = 16B;
          ins->type = 3;
          D.36883 = alloc_dreg (cfg, 3);
          D.36884 = (int) D.36883;
          ins->dreg = D.36884;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.36885>; else goto <D.36886>;
          <D.36885>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = ins;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          ins->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          goto <D.36887>;
          <D.36886>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.36887>:
          goto <D.36888>;
          <D.36878>:
          D.36860 = vtable == 0B;
          D.36861 = (long int) D.36860;
          D.36862 = __builtin_expect (D.36861, 0);
          if (D.36862 != 0) goto <D.36889>; else goto <D.36890>;
          <D.36889>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10264, "vtable");
          <D.36890>:
          D.36891 = mono_vtable_get_static_field_data (vtable);
          D.36126 = field->offset;
          D.36892 = (sizetype) D.36126;
          addr = D.36891 + D.36892;
          D.36893 = addr == 0B;
          D.36894 = (long int) D.36893;
          D.36895 = __builtin_expect (D.36894, 0);
          if (D.36895 != 0) goto <D.36896>; else goto <D.36897>;
          <D.36896>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10266, "addr");
          <D.36897>:
          D.30241 = cfg->mempool;
          ins = mono_mempool_alloc (D.30241, 80);
          ins->data.op[1].const_val = 0;
          D.30457 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.30457;
          ins->prev = 0B;
          D.30458 = ins->prev;
          ins->next = D.30458;
          ins->opcode = 363;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.30459 = ins->sreg3;
          ins->sreg2 = D.30459;
          D.30460 = ins->sreg2;
          ins->sreg1 = D.30460;
          D.30461 = cfg->ip;
          ins->cil_code = D.30461;
          ins->data.op[0].p = addr;
          ins->type = 3;
          D.36898 = alloc_dreg (cfg, 3);
          D.36899 = (int) D.36898;
          ins->dreg = D.36899;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.36900>; else goto <D.36901>;
          <D.36900>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = ins;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          ins->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          goto <D.36902>;
          <D.36901>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.36902>:
          <D.36888>:
          goto <D.36903>;
          <D.36844>:
          {
            struct MonoInst * iargs[1];

            try
              {
                D.30241 = cfg->mempool;
                D.36904 = mono_mempool_alloc (D.30241, 80);
                iargs[0] = D.36904;
                D.36905 = iargs[0];
                D.36905 = iargs[0];
                D.36905->data.op[1].const_val = 0;
                D.36906 = D.36905->data.op[1].const_val;
                D.36905->data.op[0].const_val = D.36906;
                D.36905 = iargs[0];
                D.36905 = iargs[0];
                D.36905->prev = 0B;
                D.36907 = D.36905->prev;
                D.36905->next = D.36907;
                D.36905 = iargs[0];
                D.36905->opcode = 362;
                D.36905 = iargs[0];
                D.36905->flags = 0;
                D.36905 = iargs[0];
                D.36905->type = 0;
                D.36905 = iargs[0];
                D.36905->dreg = -1;
                D.36905 = iargs[0];
                D.36905 = iargs[0];
                D.36905 = iargs[0];
                D.36905->sreg3 = -1;
                D.36908 = D.36905->sreg3;
                D.36905->sreg2 = D.36908;
                D.36909 = D.36905->sreg2;
                D.36905->sreg1 = D.36909;
                D.36905 = iargs[0];
                D.30461 = cfg->ip;
                D.36905->cil_code = D.30461;
                D.36905 = iargs[0];
                addr.222 = (long int) addr;
                D.36910 = (unsigned int) addr.222;
                D.36911 = (long int) D.36910;
                D.36905->data.op[0].const_val = D.36911;
                D.36905 = iargs[0];
                D.36905->type = 1;
                D.36905 = iargs[0];
                D.36912 = alloc_dreg (cfg, 1);
                D.36913 = (int) D.36912;
                D.36905->dreg = D.36913;
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                if (D.30490 != 0B) goto <D.36914>; else goto <D.36915>;
                <D.36914>:
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                D.36905 = iargs[0];
                D.30490->next = D.36905;
                D.36905 = iargs[0];
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                D.36905->prev = D.30490;
                bblock.106 = cfg->cbb;
                D.36905 = iargs[0];
                bblock.106->last_ins = D.36905;
                goto <D.36916>;
                <D.36915>:
                bblock.106 = cfg->cbb;
                bblock.106 = cfg->cbb;
                D.36905 = iargs[0];
                bblock.106->last_ins = D.36905;
                D.30490 = bblock.106->last_ins;
                bblock.106->code = D.30490;
                <D.36916>:
                ins = mono_emit_jit_icall (cfg, mono_get_special_static_data, &iargs);
              }
            finally
              {
                iargs = {CLOBBER};
              }
          }
          <D.36903>:
        }
        <D.36781>:
        <D.36778>:
        <D.36693>:
        <D.36577>:
        if (op == 127) goto <D.36917>; else goto <D.36918>;
        <D.36917>:
        D.36919 = mono_class_from_mono_type (ftype);
        ins->klass = D.36919;
        ins->type = 3;
        sp.226 = sp;
        sp = sp.226 + 8;
        *sp.226 = ins;
        goto <D.36921>;
        <D.36918>:
        if (op == 128) goto <D.36922>; else goto <D.36923>;
        <D.36922>:
        {
          struct MonoInst * store;

          D.30241 = cfg->mempool;
          store = mono_mempool_alloc (D.30241, 80);
          store->data.op[1].const_val = 0;
          D.36924 = store->data.op[1].const_val;
          store->data.op[0].const_val = D.36924;
          store->prev = 0B;
          D.36925 = store->prev;
          store->next = D.36925;
          D.36926 = mono_type_to_store_membase (cfg, ftype);
          D.36927 = (short unsigned int) D.36926;
          store->opcode = D.36927;
          store->flags = 0;
          store->type = 0;
          store->dreg = -1;
          store->sreg3 = -1;
          D.36928 = store->sreg3;
          store->sreg2 = D.36928;
          D.36929 = store->sreg2;
          store->sreg1 = D.36929;
          D.30461 = cfg->ip;
          store->cil_code = D.30461;
          D.36930 = store_val->dreg;
          store->sreg1 = D.36930;
          D.30654 = ins->dreg;
          store->dreg = D.30654;
          store->data.op[0].const_val = 0;
          type_to_eval_stack_type (cfg, ftype, store);
          D.36931 = mono_class_from_mono_type (ftype);
          store->klass = D.36931;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.36932>; else goto <D.36933>;
          <D.36932>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = store;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          store->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = store;
          goto <D.36934>;
          <D.36933>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = store;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.36934>:
          D.36935 = store->flags;
          D.34312 = (unsigned char) ins_flag;
          D.36936 = D.36935 | D.34312;
          store->flags = D.36936;
        }
        goto <D.36937>;
        <D.36923>:
        {
          gboolean is_const;
          struct MonoVTable * vtable;
          void * addr;

          is_const = 0;
          vtable = 0B;
          addr = 0B;
          if (context_used == 0) goto <D.36938>; else goto <D.36939>;
          <D.36938>:
          D.30267 = cfg->domain;
          klass.144 = klass;
          vtable = mono_class_vtable (D.30267, klass.144);
          klass.144 = klass;
          if (klass.144 == 0B) goto <D.36940>; else goto <D.36942>;
          <D.36942>:
          klass.144 = klass;
          D.34697 = klass.144->exception_type;
          if (D.34697 != 0) goto <D.36940>; else goto <D.36941>;
          <D.36940>:
          klass.144 = klass;
          cfg->exception_ptr = klass.144;
          D.36943 = mini_get_debug_options ();
          D.36944 = D.36943->break_on_unverified;
          if (D.36944 != 0) goto <D.36945>; else goto load_error;
          <D.36945>:
          raise (5);
          <D.36941>:
          <D.36939>:
          D.36530 = ftype->attrs;
          D.36531 = (int) D.36530;
          D.36948 = D.36531 & 32;
          if (D.36948 != 0) goto <D.36949>; else goto <D.36950>;
          <D.36949>:
          addr = mono_aot_readonly_field_override (field);
          if (addr != 0B) goto <D.36946>; else goto <D.36951>;
          <D.36951>:
          if (context_used == 0) goto <D.36952>; else goto <D.36947>;
          <D.36952>:
          D.30632 = cfg->opt;
          D.30633 = D.30632 & 512;
          if (D.30633 == 0) goto <D.36953>; else goto <D.36947>;
          <D.36953>:
          D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.30635 = D.30634 & 33554432;
          if (D.30635 == 0) goto <D.36954>; else goto <D.36947>;
          <D.36954>:
          D.36955 = BIT_FIELD_REF <*vtable, 64, 320>;
          D.36956 = D.36955 & 274877906944;
          if (D.36956 != 0) goto <D.36946>; else goto <D.36947>;
          <D.36946>:
          {
            int ro_type;

            D.36957 = ftype->type;
            ro_type = (int) D.36957;
            if (addr == 0B) goto <D.36958>; else goto <D.36959>;
            <D.36958>:
            D.36960 = mono_vtable_get_static_field_data (vtable);
            D.36126 = field->offset;
            D.36892 = (sizetype) D.36126;
            addr = D.36960 + D.36892;
            <D.36959>:
            if (ro_type == 17) goto <D.36961>; else goto <D.36962>;
            <D.36961>:
            D.36963 = ftype->data.klass;
            D.36964 = BIT_FIELD_REF <*D.36963, 64, 256>;
            D.36965 = D.36964 & 576460752303423488;
            if (D.36965 != 0) goto <D.36966>; else goto <D.36967>;
            <D.36966>:
            D.36963 = ftype->data.klass;
            D.36968 = mono_class_enum_basetype (D.36963);
            D.36969 = D.36968->type;
            ro_type = (int) D.36969;
            <D.36967>:
            <D.36962>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.36970>; else goto <D.36971>;
            <D.36970>:
            D.30178 = method->klass;
            D.31934 = D.30178->name_space;
            D.30178 = method->klass;
            D.31935 = D.30178->name;
            D.31936 = method->name;
            D.31937 = method->signature;
            D.31938 = D.31937->param_count;
            D.31939 = (int) D.31938;
            D.36972 = mono_opcode_name (op);
            D.36973 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.31934, D.31935, D.31936, D.31939, D.36972, "method-to-ir.c", 10305);
            cfg->exception_message = D.36973;
            D.30322 = cfg->verbose_level;
            if (D.30322 > 1) goto <D.36974>; else goto <D.36975>;
            <D.36974>:
            D.31944 = cfg->exception_message;
            printf ("%s\n", D.31944);
            <D.36975>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.36971>:
            is_const = 1;
            switch (ro_type) <default: <D.27877>, case 2: <D.27854>, case 3: <D.27858>, case 4: <D.27857>, case 5: <D.27855>, case 6: <D.27860>, case 7: <D.27859>, case 8: <D.27861>, case 9: <D.27862>, case 10: <D.27872>, case 11: <D.27873>, case 12: <D.27874>, case 13: <D.27875>, case 14: <D.27867>, case 15: <D.27865>, case 17: <D.27876>, case 18: <D.27869>, case 20: <D.27871>, case 24: <D.27863>, case 25: <D.27864>, case 27: <D.27866>, case 28: <D.27868>, case 29: <D.27870>>
            <D.27854>:
            <D.27855>:
            D.30241 = cfg->mempool;
            D.36976 = mono_mempool_alloc (D.30241, 80);
            *sp = D.36976;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->data.op[1].const_val = 0;
            D.32916 = D.31240->data.op[1].const_val;
            D.31240->data.op[0].const_val = D.32916;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->prev = 0B;
            D.32917 = D.31240->prev;
            D.31240->next = D.32917;
            D.31240 = *sp;
            D.31240->opcode = 362;
            D.31240 = *sp;
            D.31240->flags = 0;
            D.31240 = *sp;
            D.31240->type = 0;
            D.31240 = *sp;
            D.31240->dreg = -1;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->sreg3 = -1;
            D.32918 = D.31240->sreg3;
            D.31240->sreg2 = D.32918;
            D.32919 = D.31240->sreg2;
            D.31240->sreg1 = D.32919;
            D.31240 = *sp;
            D.30461 = cfg->ip;
            D.31240->cil_code = D.30461;
            D.31240 = *sp;
            D.36977 = MEM[(guint8 *)addr];
            D.36978 = (long int) D.36977;
            D.31240->data.op[0].const_val = D.36978;
            D.31240 = *sp;
            D.31240->type = 1;
            D.31240 = *sp;
            D.36979 = alloc_dreg (cfg, 1);
            D.36980 = (int) D.36979;
            D.31240->dreg = D.36980;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.36981>; else goto <D.36982>;
            <D.36981>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240 = *sp;
            D.30490->next = D.31240;
            D.31240 = *sp;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            goto <D.36983>;
            <D.36982>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.36983>:
            sp = sp + 8;
            goto <D.27856>;
            <D.27857>:
            D.30241 = cfg->mempool;
            D.36984 = mono_mempool_alloc (D.30241, 80);
            *sp = D.36984;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->data.op[1].const_val = 0;
            D.32916 = D.31240->data.op[1].const_val;
            D.31240->data.op[0].const_val = D.32916;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->prev = 0B;
            D.32917 = D.31240->prev;
            D.31240->next = D.32917;
            D.31240 = *sp;
            D.31240->opcode = 362;
            D.31240 = *sp;
            D.31240->flags = 0;
            D.31240 = *sp;
            D.31240->type = 0;
            D.31240 = *sp;
            D.31240->dreg = -1;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->sreg3 = -1;
            D.32918 = D.31240->sreg3;
            D.31240->sreg2 = D.32918;
            D.32919 = D.31240->sreg2;
            D.31240->sreg1 = D.32919;
            D.31240 = *sp;
            D.30461 = cfg->ip;
            D.31240->cil_code = D.30461;
            D.31240 = *sp;
            D.36985 = MEM[(gint8 *)addr];
            D.36986 = (long int) D.36985;
            D.31240->data.op[0].const_val = D.36986;
            D.31240 = *sp;
            D.31240->type = 1;
            D.31240 = *sp;
            D.36987 = alloc_dreg (cfg, 1);
            D.36988 = (int) D.36987;
            D.31240->dreg = D.36988;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.36989>; else goto <D.36990>;
            <D.36989>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240 = *sp;
            D.30490->next = D.31240;
            D.31240 = *sp;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            goto <D.36991>;
            <D.36990>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.36991>:
            sp = sp + 8;
            goto <D.27856>;
            <D.27858>:
            <D.27859>:
            D.30241 = cfg->mempool;
            D.36992 = mono_mempool_alloc (D.30241, 80);
            *sp = D.36992;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->data.op[1].const_val = 0;
            D.32916 = D.31240->data.op[1].const_val;
            D.31240->data.op[0].const_val = D.32916;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->prev = 0B;
            D.32917 = D.31240->prev;
            D.31240->next = D.32917;
            D.31240 = *sp;
            D.31240->opcode = 362;
            D.31240 = *sp;
            D.31240->flags = 0;
            D.31240 = *sp;
            D.31240->type = 0;
            D.31240 = *sp;
            D.31240->dreg = -1;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->sreg3 = -1;
            D.32918 = D.31240->sreg3;
            D.31240->sreg2 = D.32918;
            D.32919 = D.31240->sreg2;
            D.31240->sreg1 = D.32919;
            D.31240 = *sp;
            D.30461 = cfg->ip;
            D.31240->cil_code = D.30461;
            D.31240 = *sp;
            D.36993 = MEM[(guint16 *)addr];
            D.36994 = (long int) D.36993;
            D.31240->data.op[0].const_val = D.36994;
            D.31240 = *sp;
            D.31240->type = 1;
            D.31240 = *sp;
            D.36995 = alloc_dreg (cfg, 1);
            D.36996 = (int) D.36995;
            D.31240->dreg = D.36996;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.36997>; else goto <D.36998>;
            <D.36997>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240 = *sp;
            D.30490->next = D.31240;
            D.31240 = *sp;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            goto <D.36999>;
            <D.36998>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.36999>:
            sp = sp + 8;
            goto <D.27856>;
            <D.27860>:
            D.30241 = cfg->mempool;
            D.37000 = mono_mempool_alloc (D.30241, 80);
            *sp = D.37000;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->data.op[1].const_val = 0;
            D.32916 = D.31240->data.op[1].const_val;
            D.31240->data.op[0].const_val = D.32916;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->prev = 0B;
            D.32917 = D.31240->prev;
            D.31240->next = D.32917;
            D.31240 = *sp;
            D.31240->opcode = 362;
            D.31240 = *sp;
            D.31240->flags = 0;
            D.31240 = *sp;
            D.31240->type = 0;
            D.31240 = *sp;
            D.31240->dreg = -1;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->sreg3 = -1;
            D.32918 = D.31240->sreg3;
            D.31240->sreg2 = D.32918;
            D.32919 = D.31240->sreg2;
            D.31240->sreg1 = D.32919;
            D.31240 = *sp;
            D.30461 = cfg->ip;
            D.31240->cil_code = D.30461;
            D.31240 = *sp;
            D.37001 = MEM[(gint16 *)addr];
            D.37002 = (long int) D.37001;
            D.31240->data.op[0].const_val = D.37002;
            D.31240 = *sp;
            D.31240->type = 1;
            D.31240 = *sp;
            D.37003 = alloc_dreg (cfg, 1);
            D.37004 = (int) D.37003;
            D.31240->dreg = D.37004;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37005>; else goto <D.37006>;
            <D.37005>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240 = *sp;
            D.30490->next = D.31240;
            D.31240 = *sp;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            goto <D.37007>;
            <D.37006>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37007>:
            sp = sp + 8;
            goto <D.27856>;
            <D.27861>:
            D.30241 = cfg->mempool;
            D.37008 = mono_mempool_alloc (D.30241, 80);
            *sp = D.37008;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->data.op[1].const_val = 0;
            D.32916 = D.31240->data.op[1].const_val;
            D.31240->data.op[0].const_val = D.32916;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->prev = 0B;
            D.32917 = D.31240->prev;
            D.31240->next = D.32917;
            D.31240 = *sp;
            D.31240->opcode = 362;
            D.31240 = *sp;
            D.31240->flags = 0;
            D.31240 = *sp;
            D.31240->type = 0;
            D.31240 = *sp;
            D.31240->dreg = -1;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->sreg3 = -1;
            D.32918 = D.31240->sreg3;
            D.31240->sreg2 = D.32918;
            D.32919 = D.31240->sreg2;
            D.31240->sreg1 = D.32919;
            D.31240 = *sp;
            D.30461 = cfg->ip;
            D.31240->cil_code = D.30461;
            D.31240 = *sp;
            D.37009 = MEM[(gint32 *)addr];
            D.37010 = (long int) D.37009;
            D.31240->data.op[0].const_val = D.37010;
            D.31240 = *sp;
            D.31240->type = 1;
            D.31240 = *sp;
            D.37011 = alloc_dreg (cfg, 1);
            D.37012 = (int) D.37011;
            D.31240->dreg = D.37012;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37013>; else goto <D.37014>;
            <D.37013>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240 = *sp;
            D.30490->next = D.31240;
            D.31240 = *sp;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            goto <D.37015>;
            <D.37014>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37015>:
            sp = sp + 8;
            goto <D.27856>;
            <D.27862>:
            D.30241 = cfg->mempool;
            D.37016 = mono_mempool_alloc (D.30241, 80);
            *sp = D.37016;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->data.op[1].const_val = 0;
            D.32916 = D.31240->data.op[1].const_val;
            D.31240->data.op[0].const_val = D.32916;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->prev = 0B;
            D.32917 = D.31240->prev;
            D.31240->next = D.32917;
            D.31240 = *sp;
            D.31240->opcode = 362;
            D.31240 = *sp;
            D.31240->flags = 0;
            D.31240 = *sp;
            D.31240->type = 0;
            D.31240 = *sp;
            D.31240->dreg = -1;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->sreg3 = -1;
            D.32918 = D.31240->sreg3;
            D.31240->sreg2 = D.32918;
            D.32919 = D.31240->sreg2;
            D.31240->sreg1 = D.32919;
            D.31240 = *sp;
            D.30461 = cfg->ip;
            D.31240->cil_code = D.30461;
            D.31240 = *sp;
            D.37017 = MEM[(guint32 *)addr];
            D.37018 = (long int) D.37017;
            D.31240->data.op[0].const_val = D.37018;
            D.31240 = *sp;
            D.31240->type = 1;
            D.31240 = *sp;
            D.37019 = alloc_dreg (cfg, 1);
            D.37020 = (int) D.37019;
            D.31240->dreg = D.37020;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37021>; else goto <D.37022>;
            <D.37021>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240 = *sp;
            D.30490->next = D.31240;
            D.31240 = *sp;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            goto <D.37023>;
            <D.37022>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37023>:
            sp = sp + 8;
            goto <D.27856>;
            <D.27863>:
            <D.27864>:
            <D.27865>:
            <D.27866>:
            D.30241 = cfg->mempool;
            D.37024 = mono_mempool_alloc (D.30241, 80);
            *sp = D.37024;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->data.op[1].const_val = 0;
            D.32916 = D.31240->data.op[1].const_val;
            D.31240->data.op[0].const_val = D.32916;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->prev = 0B;
            D.32917 = D.31240->prev;
            D.31240->next = D.32917;
            D.31240 = *sp;
            D.31240->opcode = 363;
            D.31240 = *sp;
            D.31240->flags = 0;
            D.31240 = *sp;
            D.31240->type = 0;
            D.31240 = *sp;
            D.31240->dreg = -1;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->sreg3 = -1;
            D.32918 = D.31240->sreg3;
            D.31240->sreg2 = D.32918;
            D.32919 = D.31240->sreg2;
            D.31240->sreg1 = D.32919;
            D.31240 = *sp;
            D.30461 = cfg->ip;
            D.31240->cil_code = D.30461;
            D.31240 = *sp;
            D.37025 = MEM[(void * *)addr];
            D.31240->data.op[0].p = D.37025;
            D.31240 = *sp;
            D.31240->type = 3;
            D.31240 = *sp;
            D.37026 = alloc_dreg (cfg, 3);
            D.37027 = (int) D.37026;
            D.31240->dreg = D.37027;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37028>; else goto <D.37029>;
            <D.37028>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240 = *sp;
            D.30490->next = D.31240;
            D.31240 = *sp;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            goto <D.37030>;
            <D.37029>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37030>:
            D.36116 = field->type;
            D.31240 = *sp;
            type_to_eval_stack_type (cfg, D.36116, D.31240);
            sp = sp + 8;
            goto <D.27856>;
            <D.27867>:
            <D.27868>:
            <D.27869>:
            <D.27870>:
            <D.27871>:
            D.37031 = mono_gc_is_moving ();
            if (D.37031 == 0) goto <D.37032>; else goto <D.37033>;
            <D.37032>:
            D.30241 = cfg->mempool;
            D.37034 = mono_mempool_alloc (D.30241, 80);
            *sp = D.37034;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->data.op[1].const_val = 0;
            D.32916 = D.31240->data.op[1].const_val;
            D.31240->data.op[0].const_val = D.32916;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->prev = 0B;
            D.32917 = D.31240->prev;
            D.31240->next = D.32917;
            D.31240 = *sp;
            D.31240->opcode = 363;
            D.31240 = *sp;
            D.31240->flags = 0;
            D.31240 = *sp;
            D.31240->type = 0;
            D.31240 = *sp;
            D.31240->dreg = -1;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->sreg3 = -1;
            D.32918 = D.31240->sreg3;
            D.31240->sreg2 = D.32918;
            D.32919 = D.31240->sreg2;
            D.31240->sreg1 = D.32919;
            D.31240 = *sp;
            D.30461 = cfg->ip;
            D.31240->cil_code = D.30461;
            D.31240 = *sp;
            D.37025 = MEM[(void * *)addr];
            D.31240->data.op[0].p = D.37025;
            D.31240 = *sp;
            D.31240->type = 3;
            D.31240 = *sp;
            D.37035 = alloc_dreg (cfg, 3);
            D.37036 = (int) D.37035;
            D.31240->dreg = D.37036;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37037>; else goto <D.37038>;
            <D.37037>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240 = *sp;
            D.30490->next = D.31240;
            D.31240 = *sp;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            goto <D.37039>;
            <D.37038>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37039>:
            D.36116 = field->type;
            D.31240 = *sp;
            type_to_eval_stack_type (cfg, D.36116, D.31240);
            sp = sp + 8;
            goto <D.37040>;
            <D.37033>:
            is_const = 0;
            <D.37040>:
            goto <D.27856>;
            <D.27872>:
            <D.27873>:
            D.30241 = cfg->mempool;
            D.37041 = mono_mempool_alloc (D.30241, 80);
            *sp = D.37041;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->data.op[1].const_val = 0;
            D.32916 = D.31240->data.op[1].const_val;
            D.31240->data.op[0].const_val = D.32916;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->prev = 0B;
            D.32917 = D.31240->prev;
            D.31240->next = D.32917;
            D.31240 = *sp;
            D.31240->opcode = 363;
            D.31240 = *sp;
            D.31240->flags = 0;
            D.31240 = *sp;
            D.31240->type = 0;
            D.31240 = *sp;
            D.31240->dreg = -1;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240 = *sp;
            D.31240->sreg3 = -1;
            D.32918 = D.31240->sreg3;
            D.31240->sreg2 = D.32918;
            D.32919 = D.31240->sreg2;
            D.31240->sreg1 = D.32919;
            D.31240 = *sp;
            D.30461 = cfg->ip;
            D.31240->cil_code = D.30461;
            D.31240 = *sp;
            D.37042 = alloc_lreg (cfg);
            D.37043 = (int) D.37042;
            D.31240->dreg = D.37043;
            D.31240 = *sp;
            D.31240->type = 2;
            D.31240 = *sp;
            D.37044 = MEM[(gint64 *)addr];
            D.31240->data.i8const = D.37044;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37045>; else goto <D.37046>;
            <D.37045>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240 = *sp;
            D.30490->next = D.31240;
            D.31240 = *sp;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.31240->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            goto <D.37047>;
            <D.37046>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.31240 = *sp;
            bblock.106->last_ins = D.31240;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37047>:
            sp = sp + 8;
            goto <D.27856>;
            <D.27874>:
            <D.27875>:
            <D.27876>:
            <D.27877>:
            is_const = 0;
            goto <D.27856>;
            <D.27856>:
          }
          <D.36947>:
          <D.36950>:
          if (is_const == 0) goto <D.37048>; else goto <D.37049>;
          <D.37048>:
          {
            struct MonoInst * load;

            sp.71 = (long int) sp;
            stack_start.72 = (long int) stack_start;
            D.31013 = sp.71 - stack_start.72;
            D.31014 = D.31013 /[ex] 8;
            D.30924 = header->max_stack;
            D.31146 = (long int) D.30924;
            if (D.31014 >= D.31146) goto <D.37050>; else goto <D.37051>;
            <D.37050>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.37052>; else goto <D.37053>;
            <D.37052>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.37054>; else goto <D.37055>;
            <D.37054>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.37055>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.37053>:
            D.37056 = mini_get_debug_options ();
            D.37057 = D.37056->break_on_unverified;
            if (D.37057 != 0) goto <D.37058>; else goto unverified;
            <D.37058>:
            raise (5);
            <D.37051>:
            D.30241 = cfg->mempool;
            load = mono_mempool_alloc (D.30241, 80);
            load->data.op[1].const_val = 0;
            D.37059 = load->data.op[1].const_val;
            load->data.op[0].const_val = D.37059;
            load->prev = 0B;
            D.37060 = load->prev;
            load->next = D.37060;
            D.36116 = field->type;
            D.37061 = mono_type_to_load_membase (cfg, D.36116);
            D.37062 = (short unsigned int) D.37061;
            load->opcode = D.37062;
            load->flags = 0;
            load->type = 0;
            load->dreg = -1;
            load->sreg3 = -1;
            D.37063 = load->sreg3;
            load->sreg2 = D.37063;
            D.37064 = load->sreg2;
            load->sreg1 = D.37064;
            D.30461 = cfg->ip;
            load->cil_code = D.30461;
            load->dreg = 0;
            D.30654 = ins->dreg;
            load->sreg1 = D.30654;
            load->data.op[0].const_val = 0;
            load->type = 1;
            D.36116 = field->type;
            type_to_eval_stack_type (cfg, D.36116, load);
            D.37065 = load->type;
            D.37066 = (<unnamed type>) D.37065;
            D.37067 = alloc_dreg (cfg, D.37066);
            D.37068 = (int) D.37067;
            load->dreg = D.37068;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37069>; else goto <D.37070>;
            <D.37069>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = load;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            load->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = load;
            goto <D.37071>;
            <D.37070>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = load;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37071>:
            D.37072 = load->flags;
            D.34312 = (unsigned char) ins_flag;
            D.37073 = D.37072 | D.34312;
            load->flags = D.37073;
            ins_flag = 0;
            sp.227 = sp;
            sp = sp.227 + 8;
            *sp.227 = load;
          }
          <D.37049>:
        }
        <D.36937>:
        <D.36921>:
        ins_flag = 0;
        ip = ip + 5;
        goto <D.27394>;
      }
      <D.27879>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 15) goto <D.37075>; else goto <D.37076>;
      <D.37075>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.37077>; else goto <D.37078>;
      <D.37077>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.37079>; else goto <D.37080>;
      <D.37079>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.37080>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.37078>:
      D.37081 = mini_get_debug_options ();
      D.37082 = D.37081->break_on_unverified;
      if (D.37082 != 0) goto <D.37083>; else goto unverified;
      <D.37083>:
      raise (5);
      <D.37076>:
      sp = sp + 18446744073709551600;
      D.31664 = ip + 5;
      if (D.31664 > end) goto <D.37084>; else goto <D.37085>;
      <D.37084>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.37086>; else goto <D.37087>;
      <D.37086>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.37088>; else goto <D.37089>;
      <D.37088>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.37089>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.37087>:
      D.37090 = mini_get_debug_options ();
      D.37091 = D.37090->break_on_unverified;
      if (D.37091 != 0) goto <D.37092>; else goto unverified;
      <D.37092>:
      raise (5);
      <D.37085>:
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31684 = D.31683 << 24;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31685 = D.31683 >> 8;
      D.31686 = D.31685 & 65280;
      D.31687 = D.31684 | D.31686;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31688 = D.31683 << 8;
      D.31689 = D.31688 & 16711680;
      D.31690 = D.31687 | D.31689;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31691 = D.31683 >> 24;
      token = D.31690 | D.31691;
      klass.228 = mini_get_class (method, token, generic_context);
      klass = klass.228;
      klass.144 = klass;
      if (klass.144 == 0B) goto <D.37094>; else goto <D.37096>;
      <D.37096>:
      klass.144 = klass;
      D.34697 = klass.144->exception_type;
      if (D.34697 != 0) goto <D.37094>; else goto <D.37095>;
      <D.37094>:
      klass.144 = klass;
      cfg->exception_ptr = klass.144;
      D.37097 = mini_get_debug_options ();
      D.37098 = D.37097->break_on_unverified;
      if (D.37098 != 0) goto <D.37099>; else goto load_error;
      <D.37099>:
      raise (5);
      <D.37095>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      klass.144 = klass;
      D.34771 = &klass.144->byval_arg;
      D.37100 = mono_type_to_store_membase (cfg, D.34771);
      D.37101 = (short unsigned int) D.37100;
      ins->opcode = D.37101;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      D.32380 = D.32379->dreg;
      ins->sreg1 = D.32380;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->dreg = D.31422;
      ins->data.op[0].const_val = 0;
      klass.144 = klass;
      D.34771 = &klass.144->byval_arg;
      type_to_eval_stack_type (cfg, D.34771, ins);
      klass.144 = klass;
      D.34771 = &klass.144->byval_arg;
      D.37102 = mono_class_from_mono_type (D.34771);
      ins->klass = D.37102;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.37103>; else goto <D.37104>;
      <D.37103>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.37105>;
      <D.37104>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.37105>:
      D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.33278 = D.30634 & 8;
      if (D.33278 != 0) goto <D.37106>; else goto <D.37107>;
      <D.37106>:
      D.30211 = cfg->method;
      D.32174 = BIT_FIELD_REF <*D.30211, 64, 256>;
      D.32175 = D.32174 & 4467570830351532032;
      if (D.32175 != 3458764513820540928) goto <D.37108>; else goto <D.37109>;
      <D.37108>:
      klass.144 = klass;
      D.37110 = generic_class_is_reference_type (cfg, klass.144);
      if (D.37110 != 0) goto <D.37111>; else goto <D.37112>;
      <D.37111>:
      D.31240 = *sp;
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      emit_write_barrier (cfg, D.31240, D.32379);
      <D.37112>:
      <D.37109>:
      <D.37107>:
      ins_flag = 0;
      ip = ip + 5;
      inline_costs = inline_costs + 1;
      goto <D.27394>;
      <D.27880>:
      {
        struct MonoInst * len_ins;
        const char * data_ptr;
        int data_size;
        guint32 field_token;

        try
          {
            data_size = 0;
            sp.71 = (long int) sp;
            stack_start.72 = (long int) stack_start;
            D.31013 = sp.71 - stack_start.72;
            if (D.31013 <= 7) goto <D.37113>; else goto <D.37114>;
            <D.37113>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.37115>; else goto <D.37116>;
            <D.37115>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.37117>; else goto <D.37118>;
            <D.37117>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.37118>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.37116>:
            D.37119 = mini_get_debug_options ();
            D.37120 = D.37119->break_on_unverified;
            if (D.37120 != 0) goto <D.37121>; else goto unverified;
            <D.37121>:
            raise (5);
            <D.37114>:
            sp = sp + 18446744073709551608;
            D.31664 = ip + 5;
            if (D.31664 > end) goto <D.37122>; else goto <D.37123>;
            <D.37122>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.37124>; else goto <D.37125>;
            <D.37124>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.37126>; else goto <D.37127>;
            <D.37126>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.37127>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.37125>:
            D.37128 = mini_get_debug_options ();
            D.37129 = D.37128->break_on_unverified;
            if (D.37129 != 0) goto <D.37130>; else goto unverified;
            <D.37130>:
            raise (5);
            <D.37123>:
            D.31270 = ip + 1;
            D.31683 = MEM[(const guint32 *)D.31270];
            D.31684 = D.31683 << 24;
            D.31270 = ip + 1;
            D.31683 = MEM[(const guint32 *)D.31270];
            D.31685 = D.31683 >> 8;
            D.31686 = D.31685 & 65280;
            D.31687 = D.31684 | D.31686;
            D.31270 = ip + 1;
            D.31683 = MEM[(const guint32 *)D.31270];
            D.31688 = D.31683 << 8;
            D.31689 = D.31688 & 16711680;
            D.31690 = D.31687 | D.31689;
            D.31270 = ip + 1;
            D.31683 = MEM[(const guint32 *)D.31270];
            D.31691 = D.31683 >> 24;
            token = D.31690 | D.31691;
            klass.229 = mini_get_class (method, token, generic_context);
            klass = klass.229;
            klass.144 = klass;
            if (klass.144 == 0B) goto <D.37132>; else goto <D.37134>;
            <D.37134>:
            klass.144 = klass;
            D.34697 = klass.144->exception_type;
            if (D.34697 != 0) goto <D.37132>; else goto <D.37133>;
            <D.37132>:
            klass.144 = klass;
            cfg->exception_ptr = klass.144;
            D.37135 = mini_get_debug_options ();
            D.37136 = D.37135->break_on_unverified;
            if (D.37136 != 0) goto <D.37137>; else goto load_error;
            <D.37137>:
            raise (5);
            <D.37133>:
            klass.144 = klass;
            context_used = mini_class_check_context_used (cfg, klass.144);
            D.31240 = *sp;
            D.32922 = D.31240->type;
            D.37138 = D.32922 + 254;
            if (D.37138 <= 1) goto <D.37139>; else goto <D.37140>;
            <D.37139>:
            D.30241 = cfg->mempool;
            ins = mono_mempool_alloc (D.30241, 80);
            ins->data.op[1].const_val = 0;
            D.30457 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.30457;
            ins->prev = 0B;
            D.30458 = ins->prev;
            ins->next = D.30458;
            ins->opcode = 528;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.30459 = ins->sreg3;
            ins->sreg2 = D.30459;
            D.30460 = ins->sreg2;
            ins->sreg1 = D.30460;
            D.30461 = cfg->ip;
            ins->cil_code = D.30461;
            D.31240 = *sp;
            D.31422 = D.31240->dreg;
            ins->sreg1 = D.31422;
            ins->type = 1;
            D.37141 = alloc_ireg (cfg);
            D.37142 = (int) D.37141;
            ins->dreg = D.37142;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37143>; else goto <D.37144>;
            <D.37143>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = ins;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            ins->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            goto <D.37145>;
            <D.37144>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37145>:
            D.37146 = mono_decompose_opcode (cfg, ins);
            *sp = D.37146;
            <D.37140>:
            if (context_used != 0) goto <D.37147>; else goto <D.37148>;
            <D.37147>:
            {
              struct MonoInst * args[3];
              struct MonoClass * array_class;
              struct MonoMethod * managed_alloc;

              try
                {
                  klass.144 = klass;
                  array_class = mono_array_class_get (klass.144, 1);
                  managed_alloc = mono_gc_get_managed_array_allocator (array_class);
                  D.37149 = emit_get_rgctx_klass (cfg, context_used, array_class, 2);
                  args[0] = D.37149;
                  D.31240 = *sp;
                  args[1] = D.31240;
                  if (managed_alloc != 0B) goto <D.37150>; else goto <D.37151>;
                  <D.37150>:
                  ins = mono_emit_method_call (cfg, managed_alloc, &args, 0B);
                  goto <D.37152>;
                  <D.37151>:
                  ins = mono_emit_jit_icall (cfg, mono_array_new_specific, &args);
                  <D.37152>:
                }
              finally
                {
                  args = {CLOBBER};
                }
            }
            goto <D.37153>;
            <D.37148>:
            D.30632 = cfg->opt;
            D.30633 = D.30632 & 512;
            if (D.30633 != 0) goto <D.37154>; else goto <D.37155>;
            <D.37154>:
            {
              struct MonoInst * iargs[3];

              try
                {
                  D.30632 = cfg->opt;
                  D.30633 = D.30632 & 512;
                  if (D.30633 != 0) goto <D.37156>; else goto <D.37159>;
                  <D.37159>:
                  D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
                  D.30635 = D.30634 & 33554432;
                  if (D.30635 != 0) goto <D.37156>; else goto <D.37157>;
                  <D.37156>:
                  {
                    struct MonoInst * __domain_var;

                    __domain_var = mono_get_domainvar (cfg);
                    D.30241 = cfg->mempool;
                    D.37160 = mono_mempool_alloc (D.30241, 80);
                    iargs[0] = D.37160;
                    D.37161 = iargs[0];
                    D.37161 = iargs[0];
                    D.37161->data.op[1].const_val = 0;
                    D.37162 = D.37161->data.op[1].const_val;
                    D.37161->data.op[0].const_val = D.37162;
                    D.37161 = iargs[0];
                    D.37161 = iargs[0];
                    D.37161->prev = 0B;
                    D.37163 = D.37161->prev;
                    D.37161->next = D.37163;
                    D.37161 = iargs[0];
                    D.37161->opcode = 424;
                    D.37161 = iargs[0];
                    D.37161->flags = 0;
                    D.37161 = iargs[0];
                    D.37161->type = 0;
                    D.37161 = iargs[0];
                    D.37161->dreg = -1;
                    D.37161 = iargs[0];
                    D.37161 = iargs[0];
                    D.37161 = iargs[0];
                    D.37161->sreg3 = -1;
                    D.37164 = D.37161->sreg3;
                    D.37161->sreg2 = D.37164;
                    D.37165 = D.37161->sreg2;
                    D.37161->sreg1 = D.37165;
                    D.37161 = iargs[0];
                    D.30461 = cfg->ip;
                    D.37161->cil_code = D.30461;
                    D.37161 = iargs[0];
                    D.30978 = cfg->varinfo;
                    D.37166 = __domain_var->data.op[0].const_val;
                    D.37167 = (long unsigned int) D.37166;
                    D.37168 = D.37167 * 8;
                    D.37169 = D.30978 + D.37168;
                    D.37170 = *D.37169;
                    D.37171 = D.37170->data.op[1].vtype;
                    D.37172 = mono_type_to_regmove (cfg, D.37171);
                    D.37173 = (short unsigned int) D.37172;
                    D.37161->opcode = D.37173;
                    D.30978 = cfg->varinfo;
                    D.37166 = __domain_var->data.op[0].const_val;
                    D.37167 = (long unsigned int) D.37166;
                    D.37168 = D.37167 * 8;
                    D.37169 = D.30978 + D.37168;
                    D.37170 = *D.37169;
                    D.37171 = D.37170->data.op[1].vtype;
                    D.37161 = iargs[0];
                    type_to_eval_stack_type (cfg, D.37171, D.37161);
                    D.37161 = iargs[0];
                    D.30978 = cfg->varinfo;
                    D.37166 = __domain_var->data.op[0].const_val;
                    D.37167 = (long unsigned int) D.37166;
                    D.37168 = D.37167 * 8;
                    D.37169 = D.30978 + D.37168;
                    D.37170 = *D.37169;
                    D.37174 = D.37170->klass;
                    D.37161->klass = D.37174;
                    D.37161 = iargs[0];
                    D.30978 = cfg->varinfo;
                    D.37166 = __domain_var->data.op[0].const_val;
                    D.37167 = (long unsigned int) D.37166;
                    D.37168 = D.37167 * 8;
                    D.37169 = D.30978 + D.37168;
                    D.37170 = *D.37169;
                    D.37175 = D.37170->dreg;
                    D.37161->sreg1 = D.37175;
                    D.37161 = iargs[0];
                    D.37161 = iargs[0];
                    D.37176 = D.37161->type;
                    D.37177 = (<unnamed type>) D.37176;
                    D.37178 = alloc_dreg (cfg, D.37177);
                    D.37179 = (int) D.37178;
                    D.37161->dreg = D.37179;
                    D.37161 = iargs[0];
                    D.37180 = D.37161->opcode;
                    if (D.37180 == 427) goto <D.37181>; else goto <D.37182>;
                    <D.37181>:
                    D.37161 = iargs[0];
                    D.30978 = cfg->varinfo;
                    D.37166 = __domain_var->data.op[0].const_val;
                    D.37167 = (long unsigned int) D.37166;
                    D.37168 = D.37167 * 8;
                    D.37169 = D.30978 + D.37168;
                    D.37170 = *D.37169;
                    D.37171 = D.37170->data.op[1].vtype;
                    D.37183 = mono_class_from_mono_type (D.37171);
                    D.37161->klass = D.37183;
                    <D.37182>:
                  }
                  goto <D.37158>;
                  <D.37157>:
                  D.30241 = cfg->mempool;
                  D.37184 = mono_mempool_alloc (D.30241, 80);
                  iargs[0] = D.37184;
                  D.37161 = iargs[0];
                  D.37161 = iargs[0];
                  D.37161->data.op[1].const_val = 0;
                  D.37162 = D.37161->data.op[1].const_val;
                  D.37161->data.op[0].const_val = D.37162;
                  D.37161 = iargs[0];
                  D.37161 = iargs[0];
                  D.37161->prev = 0B;
                  D.37163 = D.37161->prev;
                  D.37161->next = D.37163;
                  D.37161 = iargs[0];
                  D.37161->opcode = 363;
                  D.37161 = iargs[0];
                  D.37161->flags = 0;
                  D.37161 = iargs[0];
                  D.37161->type = 0;
                  D.37161 = iargs[0];
                  D.37161->dreg = -1;
                  D.37161 = iargs[0];
                  D.37161 = iargs[0];
                  D.37161 = iargs[0];
                  D.37161->sreg3 = -1;
                  D.37164 = D.37161->sreg3;
                  D.37161->sreg2 = D.37164;
                  D.37165 = D.37161->sreg2;
                  D.37161->sreg1 = D.37165;
                  D.37161 = iargs[0];
                  D.30461 = cfg->ip;
                  D.37161->cil_code = D.30461;
                  D.37161 = iargs[0];
                  D.30267 = cfg->domain;
                  D.37161->data.op[0].p = D.30267;
                  D.37161 = iargs[0];
                  D.37161->type = 3;
                  D.37161 = iargs[0];
                  D.37185 = alloc_dreg (cfg, 3);
                  D.37186 = (int) D.37185;
                  D.37161->dreg = D.37186;
                  <D.37158>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.37187>; else goto <D.37188>;
                  <D.37187>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.37161 = iargs[0];
                  D.30490->next = D.37161;
                  D.37161 = iargs[0];
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.37161->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  D.37161 = iargs[0];
                  bblock.106->last_ins = D.37161;
                  goto <D.37189>;
                  <D.37188>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  D.37161 = iargs[0];
                  bblock.106->last_ins = D.37161;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.37189>:
                  D.30241 = cfg->mempool;
                  D.37190 = mono_mempool_alloc (D.30241, 80);
                  iargs[1] = D.37190;
                  D.37191 = iargs[1];
                  D.37191 = iargs[1];
                  D.37191->data.op[1].const_val = 0;
                  D.37192 = D.37191->data.op[1].const_val;
                  D.37191->data.op[0].const_val = D.37192;
                  D.37191 = iargs[1];
                  D.37191 = iargs[1];
                  D.37191->prev = 0B;
                  D.37193 = D.37191->prev;
                  D.37191->next = D.37193;
                  D.37191 = iargs[1];
                  D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
                  D.30635 = D.30634 & 33554432;
                  if (D.30635 != 0) goto <D.37195>; else goto <D.37196>;
                  <D.37195>:
                  iftmp.230 = 732;
                  goto <D.37197>;
                  <D.37196>:
                  iftmp.230 = 363;
                  <D.37197>:
                  D.37191->opcode = iftmp.230;
                  D.37191 = iargs[1];
                  D.37191->flags = 0;
                  D.37191 = iargs[1];
                  D.37191->type = 0;
                  D.37191 = iargs[1];
                  D.37191->dreg = -1;
                  D.37191 = iargs[1];
                  D.37191 = iargs[1];
                  D.37191 = iargs[1];
                  D.37191->sreg3 = -1;
                  D.37198 = D.37191->sreg3;
                  D.37191->sreg2 = D.37198;
                  D.37199 = D.37191->sreg2;
                  D.37191->sreg1 = D.37199;
                  D.37191 = iargs[1];
                  D.30461 = cfg->ip;
                  D.37191->cil_code = D.30461;
                  D.37191 = iargs[1];
                  klass.144 = klass;
                  D.37191->data.op[0].p = klass.144;
                  D.37191 = iargs[1];
                  D.37191->data.op[1].src = 11B;
                  D.37191 = iargs[1];
                  D.37191->type = 3;
                  D.37191 = iargs[1];
                  D.37200 = alloc_dreg (cfg, 3);
                  D.37201 = (int) D.37200;
                  D.37191->dreg = D.37201;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.37202>; else goto <D.37203>;
                  <D.37202>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.37191 = iargs[1];
                  D.30490->next = D.37191;
                  D.37191 = iargs[1];
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.37191->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  D.37191 = iargs[1];
                  bblock.106->last_ins = D.37191;
                  goto <D.37204>;
                  <D.37203>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  D.37191 = iargs[1];
                  bblock.106->last_ins = D.37191;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.37204>:
                  D.31240 = *sp;
                  iargs[2] = D.31240;
                  ins = mono_emit_jit_icall (cfg, mono_array_new, &iargs);
                }
              finally
                {
                  iargs = {CLOBBER};
                }
            }
            goto <D.37205>;
            <D.37155>:
            {
              struct MonoClass * array_type;

              klass.144 = klass;
              array_type = mono_array_class_get (klass.144, 1);
              D.30267 = cfg->domain;
              mono_class_vtable (D.30267, array_type);
              if (array_type == 0B) goto <D.37206>; else goto <D.37208>;
              <D.37208>:
              D.37209 = array_type->exception_type;
              if (D.37209 != 0) goto <D.37206>; else goto <D.37207>;
              <D.37206>:
              cfg->exception_ptr = array_type;
              D.37210 = mini_get_debug_options ();
              D.37211 = D.37210->break_on_unverified;
              if (D.37211 != 0) goto <D.37212>; else goto load_error;
              <D.37212>:
              raise (5);
              <D.37207>:
              D.30241 = cfg->mempool;
              ins = mono_mempool_alloc (D.30241, 80);
              ins->data.op[1].const_val = 0;
              D.30457 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.30457;
              ins->prev = 0B;
              D.30458 = ins->prev;
              ins->next = D.30458;
              ins->opcode = 782;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.30459 = ins->sreg3;
              ins->sreg2 = D.30459;
              D.30460 = ins->sreg2;
              ins->sreg1 = D.30460;
              D.30461 = cfg->ip;
              ins->cil_code = D.30461;
              D.37213 = alloc_ireg_ref (cfg);
              D.37214 = (int) D.37213;
              ins->dreg = D.37214;
              D.31240 = *sp;
              D.31422 = D.31240->dreg;
              ins->sreg1 = D.31422;
              klass.144 = klass;
              ins->data.op[1].klass = klass.144;
              ins->type = 6;
              ins->klass = array_type;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.37215>; else goto <D.37216>;
              <D.37215>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = ins;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              ins->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              goto <D.37217>;
              <D.37216>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.37217>:
              D.30670 = cfg->flags;
              D.37218 = D.30670 | 256;
              cfg->flags = D.37218;
              bblock.106 = cfg->cbb;
              bblock.106->has_array_access = 1;
              mono_get_got_var (cfg);
            }
            <D.37205>:
            <D.37153>:
            len_ins = *sp;
            ip = ip + 5;
            sp.231 = sp;
            sp = sp.231 + 8;
            *sp.231 = ins;
            inline_costs = inline_costs + 1;
            D.30632 = cfg->opt;
            D.32600 = D.30632 & 2048;
            if (D.32600 != 0) goto <D.37220>; else goto <D.37221>;
            <D.37220>:
            D.34754 = ip + 6;
            if (D.34754 < end) goto <D.37222>; else goto <D.37223>;
            <D.37222>:
            bblock.64 = bblock;
            D.34754 = ip + 6;
            D.37224 = ip_in_bb (cfg, bblock.64, D.34754);
            if (D.37224 != 0) goto <D.37225>; else goto <D.37226>;
            <D.37225>:
            D.37227 = len_ins->opcode;
            if (D.37227 == 362) goto <D.37228>; else goto <D.37229>;
            <D.37228>:
            D.32206 = cfg->compile_aot;
            D.32207 = (int) D.32206;
            klass.144 = klass;
            D.37230 = len_ins->data.op[0].const_val;
            D.37231 = (unsigned int) D.37230;
            data_ptr = initialize_array_data (method, D.32207, ip, klass.144, D.37231, &data_size, &field_token);
            if (data_ptr != 0B) goto <D.37232>; else goto <D.37233>;
            <D.37232>:
            {
              struct MonoMethod * memcpy_method;
              struct MonoInst * iargs[3];
              int add_reg;

              try
                {
                  memcpy_method = get_memcpy_method ();
                  D.37234 = alloc_ireg_mp (cfg);
                  add_reg = (int) D.37234;
                  D.30241 = cfg->mempool;
                  D.37235 = mono_mempool_alloc (D.30241, 80);
                  iargs[0] = D.37235;
                  D.37236 = iargs[0];
                  D.37236 = iargs[0];
                  D.37236->data.op[1].const_val = 0;
                  D.37237 = D.37236->data.op[1].const_val;
                  D.37236->data.op[0].const_val = D.37237;
                  D.37236 = iargs[0];
                  D.37236 = iargs[0];
                  D.37236->prev = 0B;
                  D.37238 = D.37236->prev;
                  D.37236->next = D.37238;
                  D.37236 = iargs[0];
                  D.37236->opcode = 538;
                  D.37236 = iargs[0];
                  D.37236->flags = 0;
                  D.37236 = iargs[0];
                  D.37236->type = 0;
                  D.37236 = iargs[0];
                  D.37236->dreg = -1;
                  D.37236 = iargs[0];
                  D.37236 = iargs[0];
                  D.37236 = iargs[0];
                  D.37236->sreg3 = -1;
                  D.37239 = D.37236->sreg3;
                  D.37236->sreg2 = D.37239;
                  D.37240 = D.37236->sreg2;
                  D.37236->sreg1 = D.37240;
                  D.37236 = iargs[0];
                  D.30461 = cfg->ip;
                  D.37236->cil_code = D.30461;
                  D.37236 = iargs[0];
                  D.37236->dreg = add_reg;
                  D.37236 = iargs[0];
                  D.30654 = ins->dreg;
                  D.37236->sreg1 = D.30654;
                  D.37236 = iargs[0];
                  D.37236->data.op[1].const_val = 32;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.37241>; else goto <D.37242>;
                  <D.37241>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.37236 = iargs[0];
                  D.30490->next = D.37236;
                  D.37236 = iargs[0];
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.37236->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  D.37236 = iargs[0];
                  bblock.106->last_ins = D.37236;
                  goto <D.37243>;
                  <D.37242>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  D.37236 = iargs[0];
                  bblock.106->last_ins = D.37236;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.37243>:
                  D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
                  D.30635 = D.30634 & 33554432;
                  if (D.30635 != 0) goto <D.37244>; else goto <D.37245>;
                  <D.37244>:
                  D.30241 = cfg->mempool;
                  D.37246 = mono_mempool_alloc (D.30241, 80);
                  iargs[1] = D.37246;
                  D.37247 = iargs[1];
                  D.37247 = iargs[1];
                  D.37247->data.op[1].const_val = 0;
                  D.37248 = D.37247->data.op[1].const_val;
                  D.37247->data.op[0].const_val = D.37248;
                  D.37247 = iargs[1];
                  D.37247 = iargs[1];
                  D.37247->prev = 0B;
                  D.37249 = D.37247->prev;
                  D.37247->next = D.37249;
                  D.37247 = iargs[1];
                  D.37247->opcode = 732;
                  D.37247 = iargs[1];
                  D.37247->flags = 0;
                  D.37247 = iargs[1];
                  D.37247->type = 0;
                  D.37247 = iargs[1];
                  D.37247->dreg = -1;
                  D.37247 = iargs[1];
                  D.37247 = iargs[1];
                  D.37247 = iargs[1];
                  D.37247->sreg3 = -1;
                  D.37250 = D.37247->sreg3;
                  D.37247->sreg2 = D.37250;
                  D.37251 = D.37247->sreg2;
                  D.37247->sreg1 = D.37251;
                  D.37247 = iargs[1];
                  D.30461 = cfg->ip;
                  D.37247->cil_code = D.30461;
                  D.37247 = iargs[1];
                  D.30241 = cfg->mempool;
                  D.30178 = method->klass;
                  D.30179 = D.30178->image;
                  field_token.232 = field_token;
                  D.37253 = mono_jump_info_token_new2 (D.30241, D.30179, field_token.232, 0B);
                  D.37247->data.op[0].p = D.37253;
                  D.37247 = iargs[1];
                  D.37247->data.op[1].p = 29B;
                  D.37247 = iargs[1];
                  D.37247->type = 3;
                  D.37247 = iargs[1];
                  D.37247->klass = 0B;
                  D.37247 = iargs[1];
                  D.37254 = alloc_dreg (cfg, 3);
                  D.37255 = (int) D.37254;
                  D.37247->dreg = D.37255;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.37256>; else goto <D.37257>;
                  <D.37256>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.37247 = iargs[1];
                  D.30490->next = D.37247;
                  D.37247 = iargs[1];
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.37247->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  D.37247 = iargs[1];
                  bblock.106->last_ins = D.37247;
                  goto <D.37258>;
                  <D.37257>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  D.37247 = iargs[1];
                  bblock.106->last_ins = D.37247;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.37258>:
                  goto <D.37259>;
                  <D.37245>:
                  D.30241 = cfg->mempool;
                  D.37260 = mono_mempool_alloc (D.30241, 80);
                  iargs[1] = D.37260;
                  D.37247 = iargs[1];
                  D.37247 = iargs[1];
                  D.37247->data.op[1].const_val = 0;
                  D.37248 = D.37247->data.op[1].const_val;
                  D.37247->data.op[0].const_val = D.37248;
                  D.37247 = iargs[1];
                  D.37247 = iargs[1];
                  D.37247->prev = 0B;
                  D.37249 = D.37247->prev;
                  D.37247->next = D.37249;
                  D.37247 = iargs[1];
                  D.37247->opcode = 363;
                  D.37247 = iargs[1];
                  D.37247->flags = 0;
                  D.37247 = iargs[1];
                  D.37247->type = 0;
                  D.37247 = iargs[1];
                  D.37247->dreg = -1;
                  D.37247 = iargs[1];
                  D.37247 = iargs[1];
                  D.37247 = iargs[1];
                  D.37247->sreg3 = -1;
                  D.37250 = D.37247->sreg3;
                  D.37247->sreg2 = D.37250;
                  D.37251 = D.37247->sreg2;
                  D.37247->sreg1 = D.37251;
                  D.37247 = iargs[1];
                  D.30461 = cfg->ip;
                  D.37247->cil_code = D.30461;
                  D.37247 = iargs[1];
                  D.37247->data.op[0].p = data_ptr;
                  D.37247 = iargs[1];
                  D.37247->type = 3;
                  D.37247 = iargs[1];
                  D.37261 = alloc_dreg (cfg, 3);
                  D.37262 = (int) D.37261;
                  D.37247->dreg = D.37262;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.37263>; else goto <D.37264>;
                  <D.37263>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.37247 = iargs[1];
                  D.30490->next = D.37247;
                  D.37247 = iargs[1];
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.37247->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  D.37247 = iargs[1];
                  bblock.106->last_ins = D.37247;
                  goto <D.37265>;
                  <D.37264>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  D.37247 = iargs[1];
                  bblock.106->last_ins = D.37247;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.37265>:
                  <D.37259>:
                  D.30241 = cfg->mempool;
                  D.37266 = mono_mempool_alloc (D.30241, 80);
                  iargs[2] = D.37266;
                  D.37267 = iargs[2];
                  D.37267 = iargs[2];
                  D.37267->data.op[1].const_val = 0;
                  D.37268 = D.37267->data.op[1].const_val;
                  D.37267->data.op[0].const_val = D.37268;
                  D.37267 = iargs[2];
                  D.37267 = iargs[2];
                  D.37267->prev = 0B;
                  D.37269 = D.37267->prev;
                  D.37267->next = D.37269;
                  D.37267 = iargs[2];
                  D.37267->opcode = 362;
                  D.37267 = iargs[2];
                  D.37267->flags = 0;
                  D.37267 = iargs[2];
                  D.37267->type = 0;
                  D.37267 = iargs[2];
                  D.37267->dreg = -1;
                  D.37267 = iargs[2];
                  D.37267 = iargs[2];
                  D.37267 = iargs[2];
                  D.37267->sreg3 = -1;
                  D.37270 = D.37267->sreg3;
                  D.37267->sreg2 = D.37270;
                  D.37271 = D.37267->sreg2;
                  D.37267->sreg1 = D.37271;
                  D.37267 = iargs[2];
                  D.30461 = cfg->ip;
                  D.37267->cil_code = D.30461;
                  D.37267 = iargs[2];
                  data_size.233 = data_size;
                  D.37273 = (long int) data_size.233;
                  D.37267->data.op[0].const_val = D.37273;
                  D.37267 = iargs[2];
                  D.37267->type = 1;
                  D.37267 = iargs[2];
                  D.37274 = alloc_dreg (cfg, 1);
                  D.37275 = (int) D.37274;
                  D.37267->dreg = D.37275;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.37276>; else goto <D.37277>;
                  <D.37276>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.37267 = iargs[2];
                  D.30490->next = D.37267;
                  D.37267 = iargs[2];
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.37267->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  D.37267 = iargs[2];
                  bblock.106->last_ins = D.37267;
                  goto <D.37278>;
                  <D.37277>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  D.37267 = iargs[2];
                  bblock.106->last_ins = D.37267;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.37278>:
                  mono_emit_method_call (cfg, memcpy_method, &iargs, 0B);
                  ip = ip + 11;
                }
              finally
                {
                  iargs = {CLOBBER};
                }
            }
            <D.37233>:
            <D.37229>:
            <D.37226>:
            <D.37223>:
            <D.37221>:
            goto <D.27394>;
          }
        finally
          {
            data_size = {CLOBBER};
            field_token = {CLOBBER};
          }
      }
      <D.27894>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.37279>; else goto <D.37280>;
      <D.37279>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.37281>; else goto <D.37282>;
      <D.37281>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.37283>; else goto <D.37284>;
      <D.37283>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.37284>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.37282>:
      D.37285 = mini_get_debug_options ();
      D.37286 = D.37285->break_on_unverified;
      if (D.37286 != 0) goto <D.37287>; else goto unverified;
      <D.37287>:
      raise (5);
      <D.37280>:
      sp = sp + 18446744073709551608;
      D.31240 = *sp;
      D.32922 = D.31240->type;
      if (D.32922 != 6) goto <D.37288>; else goto <D.37289>;
      <D.37288>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.37290>; else goto <D.37291>;
      <D.37290>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.37292>; else goto <D.37293>;
      <D.37292>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.37293>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.37291>:
      D.37294 = mini_get_debug_options ();
      D.37295 = D.37294->break_on_unverified;
      if (D.37295 != 0) goto <D.37296>; else goto unverified;
      <D.37296>:
      raise (5);
      <D.37289>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 783;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.37297 = alloc_preg (cfg);
      D.37298 = (int) D.37297;
      ins->dreg = D.37298;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      ins->type = 1;
      D.31088 = ins->flags;
      D.37299 = D.31088 | 32;
      ins->flags = D.37299;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.37300>; else goto <D.37301>;
      <D.37300>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.37302>;
      <D.37301>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.37302>:
      D.30670 = cfg->flags;
      D.37218 = D.30670 | 256;
      cfg->flags = D.37218;
      bblock.106 = cfg->cbb;
      bblock.106->has_array_access = 1;
      ip = ip + 1;
      sp.234 = sp;
      sp = sp.234 + 8;
      *sp.234 = ins;
      goto <D.27394>;
      <D.27895>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 15) goto <D.37304>; else goto <D.37305>;
      <D.37304>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.37306>; else goto <D.37307>;
      <D.37306>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.37308>; else goto <D.37309>;
      <D.37308>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.37309>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.37307>:
      D.37310 = mini_get_debug_options ();
      D.37311 = D.37310->break_on_unverified;
      if (D.37311 != 0) goto <D.37312>; else goto unverified;
      <D.37312>:
      raise (5);
      <D.37305>:
      sp = sp + 18446744073709551600;
      D.31664 = ip + 5;
      if (D.31664 > end) goto <D.37313>; else goto <D.37314>;
      <D.37313>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.37315>; else goto <D.37316>;
      <D.37315>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.37317>; else goto <D.37318>;
      <D.37317>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.37318>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.37316>:
      D.37319 = mini_get_debug_options ();
      D.37320 = D.37319->break_on_unverified;
      if (D.37320 != 0) goto <D.37321>; else goto unverified;
      <D.37321>:
      raise (5);
      <D.37314>:
      D.31240 = *sp;
      D.32922 = D.31240->type;
      if (D.32922 != 6) goto <D.37322>; else goto <D.37323>;
      <D.37322>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.37324>; else goto <D.37325>;
      <D.37324>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.37326>; else goto <D.37327>;
      <D.37326>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.37327>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.37325>:
      D.37328 = mini_get_debug_options ();
      D.37329 = D.37328->break_on_unverified;
      if (D.37329 != 0) goto <D.37330>; else goto unverified;
      <D.37330>:
      raise (5);
      <D.37323>:
      D.30670 = cfg->flags;
      D.37331 = D.30670 | 4;
      cfg->flags = D.37331;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31684 = D.31683 << 24;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31685 = D.31683 >> 8;
      D.31686 = D.31685 & 65280;
      D.31687 = D.31684 | D.31686;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31688 = D.31683 << 8;
      D.31689 = D.31688 & 16711680;
      D.31690 = D.31687 | D.31689;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31691 = D.31683 >> 24;
      D.31692 = D.31690 | D.31691;
      klass.235 = mini_get_class (method, D.31692, generic_context);
      klass = klass.235;
      klass.144 = klass;
      if (klass.144 == 0B) goto <D.37333>; else goto <D.37335>;
      <D.37335>:
      klass.144 = klass;
      D.34697 = klass.144->exception_type;
      if (D.34697 != 0) goto <D.37333>; else goto <D.37334>;
      <D.37333>:
      klass.144 = klass;
      cfg->exception_ptr = klass.144;
      D.37336 = mini_get_debug_options ();
      D.37337 = D.37336->break_on_unverified;
      if (D.37337 != 0) goto <D.37338>; else goto load_error;
      <D.37338>:
      raise (5);
      <D.37334>:
      klass.144 = klass;
      D.35477 = BIT_FIELD_REF <*klass.144, 64, 256>;
      D.36123 = D.35477 & 1152921504606846976;
      if (D.36123 == 0) goto <D.37339>; else goto <D.37340>;
      <D.37339>:
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30184 = D.30183 & 4467570830351532032;
      if (D.30184 == 0) goto <D.37341>; else goto <D.37342>;
      <D.37341>:
      if (readonly == 0) goto <D.37343>; else goto <D.37344>;
      <D.37343>:
      {
        struct MonoClass * array_class;

        klass.144 = klass;
        array_class = mono_array_class_get (klass.144, 1);
        D.31240 = *sp;
        mini_emit_check_array_type (cfg, D.31240, array_class);
        if (array_class == 0B) goto <D.37345>; else goto <D.37347>;
        <D.37347>:
        D.37348 = array_class->exception_type;
        if (D.37348 != 0) goto <D.37345>; else goto <D.37346>;
        <D.37345>:
        cfg->exception_ptr = array_class;
        D.37349 = mini_get_debug_options ();
        D.37350 = D.37349->break_on_unverified;
        if (D.37350 != 0) goto <D.37351>; else goto load_error;
        <D.37351>:
        raise (5);
        <D.37346>:
      }
      <D.37344>:
      <D.37342>:
      <D.37340>:
      readonly = 0;
      klass.144 = klass;
      D.31240 = *sp;
      D.32378 = sp + 8;
      D.32379 = *D.32378;
      ins = mini_emit_ldelema_1_ins (cfg, klass.144, D.31240, D.32379, 1);
      sp.236 = sp;
      sp = sp.236 + 8;
      *sp.236 = ins;
      ip = ip + 5;
      goto <D.27394>;
      <D.27897>:
      <D.27898>:
      <D.27899>:
      <D.27900>:
      <D.27901>:
      <D.27902>:
      <D.27903>:
      <D.27904>:
      <D.27905>:
      <D.27906>:
      <D.27907>:
      <D.27908>:
      {
        struct MonoInst * addr;

        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        if (D.31013 <= 15) goto <D.37353>; else goto <D.37354>;
        <D.37353>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.37355>; else goto <D.37356>;
        <D.37355>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.37357>; else goto <D.37358>;
        <D.37357>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.37358>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.37356>:
        D.37359 = mini_get_debug_options ();
        D.37360 = D.37359->break_on_unverified;
        if (D.37360 != 0) goto <D.37361>; else goto unverified;
        <D.37361>:
        raise (5);
        <D.37354>:
        sp = sp + 18446744073709551600;
        D.31121 = *ip;
        if (D.31121 == 163) goto <D.37362>; else goto <D.37363>;
        <D.37362>:
        D.31664 = ip + 5;
        if (D.31664 > end) goto <D.37364>; else goto <D.37365>;
        <D.37364>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.37366>; else goto <D.37367>;
        <D.37366>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.37368>; else goto <D.37369>;
        <D.37368>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.37369>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.37367>:
        D.37370 = mini_get_debug_options ();
        D.37371 = D.37370->break_on_unverified;
        if (D.37371 != 0) goto <D.37372>; else goto unverified;
        <D.37372>:
        raise (5);
        <D.37365>:
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31684 = D.31683 << 24;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31685 = D.31683 >> 8;
        D.31686 = D.31685 & 65280;
        D.31687 = D.31684 | D.31686;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31688 = D.31683 << 8;
        D.31689 = D.31688 & 16711680;
        D.31690 = D.31687 | D.31689;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31691 = D.31683 >> 24;
        token = D.31690 | D.31691;
        klass.237 = mini_get_class (method, token, generic_context);
        klass = klass.237;
        klass.144 = klass;
        if (klass.144 == 0B) goto <D.37374>; else goto <D.37376>;
        <D.37376>:
        klass.144 = klass;
        D.34697 = klass.144->exception_type;
        if (D.34697 != 0) goto <D.37374>; else goto <D.37375>;
        <D.37374>:
        klass.144 = klass;
        cfg->exception_ptr = klass.144;
        D.37377 = mini_get_debug_options ();
        D.37378 = D.37377->break_on_unverified;
        if (D.37378 != 0) goto <D.37379>; else goto load_error;
        <D.37379>:
        raise (5);
        <D.37375>:
        klass.144 = klass;
        mono_class_init (klass.144);
        goto <D.37380>;
        <D.37363>:
        D.31121 = *ip;
        D.31122 = (int) D.31121;
        klass.238 = array_access_to_klass (D.31122);
        klass = klass.238;
        <D.37380>:
        D.31240 = *sp;
        D.32922 = D.31240->type;
        if (D.32922 != 6) goto <D.37382>; else goto <D.37383>;
        <D.37382>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.37384>; else goto <D.37385>;
        <D.37384>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.37386>; else goto <D.37387>;
        <D.37386>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.37387>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.37385>:
        D.37388 = mini_get_debug_options ();
        D.37389 = D.37388->break_on_unverified;
        if (D.37389 != 0) goto <D.37390>; else goto unverified;
        <D.37390>:
        raise (5);
        <D.37383>:
        D.30670 = cfg->flags;
        D.37331 = D.30670 | 4;
        cfg->flags = D.37331;
        klass.144 = klass;
        D.37391 = mini_is_gsharedvt_variable_klass (cfg, klass.144);
        if (D.37391 != 0) goto <D.37392>; else goto <D.37393>;
        <D.37392>:
        klass.144 = klass;
        D.31240 = *sp;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        addr = mini_emit_ldelema_1_ins (cfg, klass.144, D.31240, D.32379, 1);
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        klass.144 = klass;
        D.34771 = &klass.144->byval_arg;
        D.37394 = mono_type_to_load_membase (cfg, D.34771);
        D.37395 = (short unsigned int) D.37394;
        ins->opcode = D.37395;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        ins->dreg = 0;
        D.37396 = addr->dreg;
        ins->sreg1 = D.37396;
        ins->data.op[0].const_val = 0;
        ins->type = 1;
        klass.144 = klass;
        D.34771 = &klass.144->byval_arg;
        type_to_eval_stack_type (cfg, D.34771, ins);
        D.30988 = ins->type;
        D.30989 = (<unnamed type>) D.30988;
        D.37397 = alloc_dreg (cfg, D.30989);
        D.37398 = (int) D.37397;
        ins->dreg = D.37398;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.37399>; else goto <D.37400>;
        <D.37399>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.37401>;
        <D.37400>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.37401>:
        ins->opcode = 399;
        goto <D.37402>;
        <D.37393>:
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        D.34346 = D.32379->opcode;
        if (D.34346 == 362) goto <D.37403>; else goto <D.37404>;
        <D.37403>:
        {
          int array_reg;
          int index_reg;
          int offset;

          D.31240 = *sp;
          array_reg = D.31240->dreg;
          D.32378 = sp + 8;
          D.32379 = *D.32378;
          index_reg = D.32379->dreg;
          klass.144 = klass;
          D.37405 = mono_class_array_element_size (klass.144);
          D.37406 = (unsigned int) D.37405;
          D.32378 = sp + 8;
          D.32379 = *D.32378;
          D.34371 = D.32379->data.op[0].const_val;
          D.37407 = (unsigned int) D.34371;
          D.37408 = D.37406 * D.37407;
          D.37409 = D.37408 + 32;
          offset = (int) D.37409;
          D.30632 = cfg->opt;
          D.37410 = D.30632 & 134217728;
          if (D.37410 == 0) goto <D.37411>; else goto <D.37412>;
          <D.37411>:
          D.30632 = cfg->opt;
          D.37413 = D.30632 & 262144;
          if (D.37413 == 0) goto <D.37414>; else goto <D.37415>;
          <D.37414>:
          D.30229 = BIT_FIELD_REF <*cfg, 64, 5632>;
          D.30870 = D.30229 & 144115188075855872;
          if (D.30870 != 0) goto <D.37416>; else goto <D.37417>;
          <D.37416>:
          {
            struct MonoInst * inst;

            D.30241 = cfg->mempool;
            inst = mono_mempool_alloc (D.30241, 80);
            inst->data.op[1].const_val = 0;
            D.37418 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.37418;
            inst->prev = 0B;
            D.37419 = inst->prev;
            inst->next = D.37419;
            inst->opcode = 323;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.37420 = inst->sreg3;
            inst->sreg2 = D.37420;
            D.37421 = inst->sreg2;
            inst->sreg1 = D.37421;
            D.30461 = cfg->ip;
            inst->cil_code = D.30461;
            inst->dreg = -1;
            inst->sreg1 = array_reg;
            inst->data.op[1].const_val = 0;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37422>; else goto <D.37423>;
            <D.37422>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = inst;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            inst->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            goto <D.37424>;
            <D.37423>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37424>:
          }
          {
            struct MonoInst * inst;

            D.30241 = cfg->mempool;
            inst = mono_mempool_alloc (D.30241, 80);
            inst->data.op[1].const_val = 0;
            D.37425 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.37425;
            inst->prev = 0B;
            D.37426 = inst->prev;
            inst->next = D.37426;
            inst->opcode = 451;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.37427 = inst->sreg3;
            inst->sreg2 = D.37427;
            D.37428 = inst->sreg2;
            inst->sreg1 = D.37428;
            D.30461 = cfg->ip;
            inst->cil_code = D.30461;
            inst->data.op[1].p = "NullReferenceException";
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37429>; else goto <D.37430>;
            <D.37429>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = inst;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            inst->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            goto <D.37431>;
            <D.37430>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37431>:
          }
          goto <D.37432>;
          <D.37417>:
          <D.37432>:
          if (0 != 0) goto <D.37433>; else goto <D.37434>;
          <D.37433>:
          {
            int _length_reg;

            D.37435 = alloc_ireg (cfg);
            _length_reg = (int) D.37435;
            if (1 != 0) goto <D.37436>; else goto <D.37437>;
            <D.37436>:
            {
              struct MonoInst * inst;
              int __ins_flags;

              __ins_flags = 32;
              D.37438 = __ins_flags & 32;
              if (D.37438 != 0) goto <D.37439>; else goto <D.37440>;
              <D.37439>:
              D.30229 = BIT_FIELD_REF <*cfg, 64, 5632>;
              D.30870 = D.30229 & 144115188075855872;
              if (D.30870 != 0) goto <D.37441>; else goto <D.37442>;
              <D.37441>:
              {
                struct MonoInst * inst;

                D.30241 = cfg->mempool;
                inst = mono_mempool_alloc (D.30241, 80);
                inst->data.op[1].const_val = 0;
                D.37443 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.37443;
                inst->prev = 0B;
                D.37444 = inst->prev;
                inst->next = D.37444;
                inst->opcode = 323;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.37445 = inst->sreg3;
                inst->sreg2 = D.37445;
                D.37446 = inst->sreg2;
                inst->sreg1 = D.37446;
                D.30461 = cfg->ip;
                inst->cil_code = D.30461;
                inst->dreg = -1;
                inst->sreg1 = array_reg;
                inst->data.op[1].const_val = 0;
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                if (D.30490 != 0B) goto <D.37447>; else goto <D.37448>;
                <D.37447>:
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                D.30490->next = inst;
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                inst->prev = D.30490;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                goto <D.37449>;
                <D.37448>:
                bblock.106 = cfg->cbb;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                D.30490 = bblock.106->last_ins;
                bblock.106->code = D.30490;
                <D.37449>:
              }
              {
                struct MonoInst * inst;

                D.30241 = cfg->mempool;
                inst = mono_mempool_alloc (D.30241, 80);
                inst->data.op[1].const_val = 0;
                D.37450 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.37450;
                inst->prev = 0B;
                D.37451 = inst->prev;
                inst->next = D.37451;
                inst->opcode = 451;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.37452 = inst->sreg3;
                inst->sreg2 = D.37452;
                D.37453 = inst->sreg2;
                inst->sreg1 = D.37453;
                D.30461 = cfg->ip;
                inst->cil_code = D.30461;
                inst->data.op[1].p = "NullReferenceException";
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                if (D.30490 != 0B) goto <D.37454>; else goto <D.37455>;
                <D.37454>:
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                D.30490->next = inst;
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                inst->prev = D.30490;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                goto <D.37456>;
                <D.37455>:
                bblock.106 = cfg->cbb;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                D.30490 = bblock.106->last_ins;
                bblock.106->code = D.30490;
                <D.37456>:
              }
              goto <D.37457>;
              <D.37442>:
              <D.37457>:
              <D.37440>:
              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.37458 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.37458;
              inst->prev = 0B;
              D.37459 = inst->prev;
              inst->next = D.37459;
              inst->opcode = 393;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.37460 = inst->sreg3;
              inst->sreg2 = D.37460;
              D.37461 = inst->sreg2;
              inst->sreg1 = D.37461;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = _length_reg;
              inst->sreg1 = array_reg;
              inst->data.op[0].const_val = 24;
              inst->type = 1;
              D.37462 = (unsigned char) __ins_flags;
              inst->flags = D.37462;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.37463>; else goto <D.37464>;
              <D.37463>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.37465>;
              <D.37464>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.37465>:
            }
            goto <D.37466>;
            <D.37437>:
            {
              struct MonoInst * inst;
              int __ins_flags;

              __ins_flags = 64;
              D.37467 = __ins_flags & 32;
              if (D.37467 != 0) goto <D.37468>; else goto <D.37469>;
              <D.37468>:
              D.30229 = BIT_FIELD_REF <*cfg, 64, 5632>;
              D.30870 = D.30229 & 144115188075855872;
              if (D.30870 != 0) goto <D.37470>; else goto <D.37471>;
              <D.37470>:
              {
                struct MonoInst * inst;

                D.30241 = cfg->mempool;
                inst = mono_mempool_alloc (D.30241, 80);
                inst->data.op[1].const_val = 0;
                D.37472 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.37472;
                inst->prev = 0B;
                D.37473 = inst->prev;
                inst->next = D.37473;
                inst->opcode = 323;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.37474 = inst->sreg3;
                inst->sreg2 = D.37474;
                D.37475 = inst->sreg2;
                inst->sreg1 = D.37475;
                D.30461 = cfg->ip;
                inst->cil_code = D.30461;
                inst->dreg = -1;
                inst->sreg1 = array_reg;
                inst->data.op[1].const_val = 0;
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                if (D.30490 != 0B) goto <D.37476>; else goto <D.37477>;
                <D.37476>:
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                D.30490->next = inst;
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                inst->prev = D.30490;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                goto <D.37478>;
                <D.37477>:
                bblock.106 = cfg->cbb;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                D.30490 = bblock.106->last_ins;
                bblock.106->code = D.30490;
                <D.37478>:
              }
              {
                struct MonoInst * inst;

                D.30241 = cfg->mempool;
                inst = mono_mempool_alloc (D.30241, 80);
                inst->data.op[1].const_val = 0;
                D.37479 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.37479;
                inst->prev = 0B;
                D.37480 = inst->prev;
                inst->next = D.37480;
                inst->opcode = 451;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.37481 = inst->sreg3;
                inst->sreg2 = D.37481;
                D.37482 = inst->sreg2;
                inst->sreg1 = D.37482;
                D.30461 = cfg->ip;
                inst->cil_code = D.30461;
                inst->data.op[1].p = "NullReferenceException";
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                if (D.30490 != 0B) goto <D.37483>; else goto <D.37484>;
                <D.37483>:
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                D.30490->next = inst;
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                inst->prev = D.30490;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                goto <D.37485>;
                <D.37484>:
                bblock.106 = cfg->cbb;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                D.30490 = bblock.106->last_ins;
                bblock.106->code = D.30490;
                <D.37485>:
              }
              goto <D.37486>;
              <D.37471>:
              <D.37486>:
              <D.37469>:
              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.37487 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.37487;
              inst->prev = 0B;
              D.37488 = inst->prev;
              inst->next = D.37488;
              inst->opcode = 393;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.37489 = inst->sreg3;
              inst->sreg2 = D.37489;
              D.37490 = inst->sreg2;
              inst->sreg1 = D.37490;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = _length_reg;
              inst->sreg1 = array_reg;
              inst->data.op[0].const_val = 24;
              inst->type = 1;
              D.37491 = (unsigned char) __ins_flags;
              inst->flags = D.37491;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.37492>; else goto <D.37493>;
              <D.37492>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.37494>;
              <D.37493>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.37494>:
            }
            <D.37466>:
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.37495 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.37495;
              inst->prev = 0B;
              D.37496 = inst->prev;
              inst->next = D.37496;
              inst->opcode = 322;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.37497 = inst->sreg3;
              inst->sreg2 = D.37497;
              D.37498 = inst->sreg2;
              inst->sreg1 = D.37498;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = -1;
              inst->sreg1 = _length_reg;
              inst->sreg2 = index_reg;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.37499>; else goto <D.37500>;
              <D.37499>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.37501>;
              <D.37500>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.37501>:
            }
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.37502 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.37502;
              inst->prev = 0B;
              D.37503 = inst->prev;
              inst->next = D.37503;
              inst->opcode = 459;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.37504 = inst->sreg3;
              inst->sreg2 = D.37504;
              D.37505 = inst->sreg2;
              inst->sreg1 = D.37505;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->data.op[1].p = "IndexOutOfRangeException";
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.37506>; else goto <D.37507>;
              <D.37506>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.37508>;
              <D.37507>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.37508>:
            }
          }
          goto <D.37509>;
          <D.37434>:
          {
            int _length_reg;

            D.37510 = alloc_ireg (cfg);
            _length_reg = (int) D.37510;
            if (1 != 0) goto <D.37511>; else goto <D.37512>;
            <D.37511>:
            {
              struct MonoInst * inst;
              int __ins_flags;

              __ins_flags = 32;
              D.37513 = __ins_flags & 32;
              if (D.37513 != 0) goto <D.37514>; else goto <D.37515>;
              <D.37514>:
              D.30229 = BIT_FIELD_REF <*cfg, 64, 5632>;
              D.30870 = D.30229 & 144115188075855872;
              if (D.30870 != 0) goto <D.37516>; else goto <D.37517>;
              <D.37516>:
              {
                struct MonoInst * inst;

                D.30241 = cfg->mempool;
                inst = mono_mempool_alloc (D.30241, 80);
                inst->data.op[1].const_val = 0;
                D.37518 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.37518;
                inst->prev = 0B;
                D.37519 = inst->prev;
                inst->next = D.37519;
                inst->opcode = 323;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.37520 = inst->sreg3;
                inst->sreg2 = D.37520;
                D.37521 = inst->sreg2;
                inst->sreg1 = D.37521;
                D.30461 = cfg->ip;
                inst->cil_code = D.30461;
                inst->dreg = -1;
                inst->sreg1 = array_reg;
                inst->data.op[1].const_val = 0;
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                if (D.30490 != 0B) goto <D.37522>; else goto <D.37523>;
                <D.37522>:
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                D.30490->next = inst;
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                inst->prev = D.30490;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                goto <D.37524>;
                <D.37523>:
                bblock.106 = cfg->cbb;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                D.30490 = bblock.106->last_ins;
                bblock.106->code = D.30490;
                <D.37524>:
              }
              {
                struct MonoInst * inst;

                D.30241 = cfg->mempool;
                inst = mono_mempool_alloc (D.30241, 80);
                inst->data.op[1].const_val = 0;
                D.37525 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.37525;
                inst->prev = 0B;
                D.37526 = inst->prev;
                inst->next = D.37526;
                inst->opcode = 451;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.37527 = inst->sreg3;
                inst->sreg2 = D.37527;
                D.37528 = inst->sreg2;
                inst->sreg1 = D.37528;
                D.30461 = cfg->ip;
                inst->cil_code = D.30461;
                inst->data.op[1].p = "NullReferenceException";
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                if (D.30490 != 0B) goto <D.37529>; else goto <D.37530>;
                <D.37529>:
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                D.30490->next = inst;
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                inst->prev = D.30490;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                goto <D.37531>;
                <D.37530>:
                bblock.106 = cfg->cbb;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                D.30490 = bblock.106->last_ins;
                bblock.106->code = D.30490;
                <D.37531>:
              }
              goto <D.37532>;
              <D.37517>:
              <D.37532>:
              <D.37515>:
              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.37533 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.37533;
              inst->prev = 0B;
              D.37534 = inst->prev;
              inst->next = D.37534;
              inst->opcode = 393;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.37535 = inst->sreg3;
              inst->sreg2 = D.37535;
              D.37536 = inst->sreg2;
              inst->sreg1 = D.37536;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = _length_reg;
              inst->sreg1 = array_reg;
              inst->data.op[0].const_val = 24;
              inst->type = 1;
              D.37537 = (unsigned char) __ins_flags;
              inst->flags = D.37537;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.37538>; else goto <D.37539>;
              <D.37538>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.37540>;
              <D.37539>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.37540>:
            }
            goto <D.37541>;
            <D.37512>:
            {
              struct MonoInst * inst;
              int __ins_flags;

              __ins_flags = 64;
              D.37542 = __ins_flags & 32;
              if (D.37542 != 0) goto <D.37543>; else goto <D.37544>;
              <D.37543>:
              D.30229 = BIT_FIELD_REF <*cfg, 64, 5632>;
              D.30870 = D.30229 & 144115188075855872;
              if (D.30870 != 0) goto <D.37545>; else goto <D.37546>;
              <D.37545>:
              {
                struct MonoInst * inst;

                D.30241 = cfg->mempool;
                inst = mono_mempool_alloc (D.30241, 80);
                inst->data.op[1].const_val = 0;
                D.37547 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.37547;
                inst->prev = 0B;
                D.37548 = inst->prev;
                inst->next = D.37548;
                inst->opcode = 323;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.37549 = inst->sreg3;
                inst->sreg2 = D.37549;
                D.37550 = inst->sreg2;
                inst->sreg1 = D.37550;
                D.30461 = cfg->ip;
                inst->cil_code = D.30461;
                inst->dreg = -1;
                inst->sreg1 = array_reg;
                inst->data.op[1].const_val = 0;
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                if (D.30490 != 0B) goto <D.37551>; else goto <D.37552>;
                <D.37551>:
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                D.30490->next = inst;
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                inst->prev = D.30490;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                goto <D.37553>;
                <D.37552>:
                bblock.106 = cfg->cbb;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                D.30490 = bblock.106->last_ins;
                bblock.106->code = D.30490;
                <D.37553>:
              }
              {
                struct MonoInst * inst;

                D.30241 = cfg->mempool;
                inst = mono_mempool_alloc (D.30241, 80);
                inst->data.op[1].const_val = 0;
                D.37554 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.37554;
                inst->prev = 0B;
                D.37555 = inst->prev;
                inst->next = D.37555;
                inst->opcode = 451;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.37556 = inst->sreg3;
                inst->sreg2 = D.37556;
                D.37557 = inst->sreg2;
                inst->sreg1 = D.37557;
                D.30461 = cfg->ip;
                inst->cil_code = D.30461;
                inst->data.op[1].p = "NullReferenceException";
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                if (D.30490 != 0B) goto <D.37558>; else goto <D.37559>;
                <D.37558>:
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                D.30490->next = inst;
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                inst->prev = D.30490;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                goto <D.37560>;
                <D.37559>:
                bblock.106 = cfg->cbb;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                D.30490 = bblock.106->last_ins;
                bblock.106->code = D.30490;
                <D.37560>:
              }
              goto <D.37561>;
              <D.37546>:
              <D.37561>:
              <D.37544>:
              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.37562 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.37562;
              inst->prev = 0B;
              D.37563 = inst->prev;
              inst->next = D.37563;
              inst->opcode = 393;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.37564 = inst->sreg3;
              inst->sreg2 = D.37564;
              D.37565 = inst->sreg2;
              inst->sreg1 = D.37565;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = _length_reg;
              inst->sreg1 = array_reg;
              inst->data.op[0].const_val = 24;
              inst->type = 1;
              D.37566 = (unsigned char) __ins_flags;
              inst->flags = D.37566;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.37567>; else goto <D.37568>;
              <D.37567>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.37569>;
              <D.37568>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.37569>:
            }
            <D.37541>:
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.37570 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.37570;
              inst->prev = 0B;
              D.37571 = inst->prev;
              inst->next = D.37571;
              inst->opcode = 322;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.37572 = inst->sreg3;
              inst->sreg2 = D.37572;
              D.37573 = inst->sreg2;
              inst->sreg1 = D.37573;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = -1;
              inst->sreg1 = _length_reg;
              inst->sreg2 = index_reg;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.37574>; else goto <D.37575>;
              <D.37574>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.37576>;
              <D.37575>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.37576>:
            }
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.37577 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.37577;
              inst->prev = 0B;
              D.37578 = inst->prev;
              inst->next = D.37578;
              inst->opcode = 459;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.37579 = inst->sreg3;
              inst->sreg2 = D.37579;
              D.37580 = inst->sreg2;
              inst->sreg1 = D.37580;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->data.op[1].p = "IndexOutOfRangeException";
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.37581>; else goto <D.37582>;
              <D.37581>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.37583>;
              <D.37582>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.37583>:
            }
          }
          <D.37509>:
          goto <D.37584>;
          <D.37415>:
          {
            struct MonoInst * ins;

            D.30241 = cfg->mempool;
            ins = mono_mempool_alloc (D.30241, 80);
            ins->data.op[1].const_val = 0;
            D.37585 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.37585;
            ins->prev = 0B;
            D.37586 = ins->prev;
            ins->next = D.37586;
            ins->opcode = 784;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.37587 = ins->sreg3;
            ins->sreg2 = D.37587;
            D.37588 = ins->sreg2;
            ins->sreg1 = D.37588;
            D.30461 = cfg->ip;
            ins->cil_code = D.30461;
            ins->sreg1 = array_reg;
            ins->sreg2 = index_reg;
            ins->data.op[1].const_val = 24;
            D.37589 = ins->flags;
            D.37590 = D.37589 | 32;
            ins->flags = D.37590;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37591>; else goto <D.37592>;
            <D.37591>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = ins;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            ins->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            goto <D.37593>;
            <D.37592>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37593>:
            D.30670 = cfg->flags;
            D.37218 = D.30670 | 256;
            cfg->flags = D.37218;
            bblock.106 = cfg->cbb;
            bblock.106->has_array_access = 1;
          }
          <D.37584>:
          <D.37412>:
          D.30241 = cfg->mempool;
          ins = mono_mempool_alloc (D.30241, 80);
          ins->data.op[1].const_val = 0;
          D.30457 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.30457;
          ins->prev = 0B;
          D.30458 = ins->prev;
          ins->next = D.30458;
          klass.144 = klass;
          D.34771 = &klass.144->byval_arg;
          D.37594 = mono_type_to_load_membase (cfg, D.34771);
          D.37595 = (short unsigned int) D.37594;
          ins->opcode = D.37595;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.30459 = ins->sreg3;
          ins->sreg2 = D.30459;
          D.30460 = ins->sreg2;
          ins->sreg1 = D.30460;
          D.30461 = cfg->ip;
          ins->cil_code = D.30461;
          ins->dreg = 0;
          ins->sreg1 = array_reg;
          D.37596 = (long int) offset;
          ins->data.op[0].const_val = D.37596;
          ins->type = 1;
          klass.144 = klass;
          D.34771 = &klass.144->byval_arg;
          type_to_eval_stack_type (cfg, D.34771, ins);
          D.30988 = ins->type;
          D.30989 = (<unnamed type>) D.30988;
          D.37597 = alloc_dreg (cfg, D.30989);
          D.37598 = (int) D.37597;
          ins->dreg = D.37598;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.37599>; else goto <D.37600>;
          <D.37599>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = ins;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          ins->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          goto <D.37601>;
          <D.37600>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = ins;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.37601>:
        }
        goto <D.37602>;
        <D.37404>:
        klass.144 = klass;
        D.31240 = *sp;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        addr = mini_emit_ldelema_1_ins (cfg, klass.144, D.31240, D.32379, 1);
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        klass.144 = klass;
        D.34771 = &klass.144->byval_arg;
        D.37603 = mono_type_to_load_membase (cfg, D.34771);
        D.37604 = (short unsigned int) D.37603;
        ins->opcode = D.37604;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        ins->dreg = 0;
        D.37396 = addr->dreg;
        ins->sreg1 = D.37396;
        ins->data.op[0].const_val = 0;
        ins->type = 1;
        klass.144 = klass;
        D.34771 = &klass.144->byval_arg;
        type_to_eval_stack_type (cfg, D.34771, ins);
        D.30988 = ins->type;
        D.30989 = (<unnamed type>) D.30988;
        D.37605 = alloc_dreg (cfg, D.30989);
        D.37606 = (int) D.37605;
        ins->dreg = D.37606;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.37607>; else goto <D.37608>;
        <D.37607>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.37609>;
        <D.37608>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.37609>:
        <D.37602>:
        <D.37402>:
        sp.239 = sp;
        sp = sp.239 + 8;
        *sp.239 = ins;
        D.31121 = *ip;
        if (D.31121 == 163) goto <D.37611>; else goto <D.37612>;
        <D.37611>:
        ip = ip + 5;
        goto <D.37613>;
        <D.37612>:
        ip = ip + 1;
        <D.37613>:
        goto <D.27394>;
      }
      <D.27938>:
      <D.27939>:
      <D.27940>:
      <D.27941>:
      <D.27942>:
      <D.27943>:
      <D.27944>:
      <D.27945>:
      <D.27946>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 23) goto <D.37614>; else goto <D.37615>;
      <D.37614>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.37616>; else goto <D.37617>;
      <D.37616>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.37618>; else goto <D.37619>;
      <D.37618>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.37619>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.37617>:
      D.37620 = mini_get_debug_options ();
      D.37621 = D.37620->break_on_unverified;
      if (D.37621 != 0) goto <D.37622>; else goto unverified;
      <D.37622>:
      raise (5);
      <D.37615>:
      sp = sp + 18446744073709551592;
      D.30670 = cfg->flags;
      D.37331 = D.30670 | 4;
      cfg->flags = D.37331;
      D.31121 = *ip;
      if (D.31121 == 164) goto <D.37623>; else goto <D.37624>;
      <D.37623>:
      D.31664 = ip + 5;
      if (D.31664 > end) goto <D.37625>; else goto <D.37626>;
      <D.37625>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.37627>; else goto <D.37628>;
      <D.37627>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.37629>; else goto <D.37630>;
      <D.37629>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.37630>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.37628>:
      D.37631 = mini_get_debug_options ();
      D.37632 = D.37631->break_on_unverified;
      if (D.37632 != 0) goto <D.37633>; else goto unverified;
      <D.37633>:
      raise (5);
      <D.37626>:
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31684 = D.31683 << 24;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31685 = D.31683 >> 8;
      D.31686 = D.31685 & 65280;
      D.31687 = D.31684 | D.31686;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31688 = D.31683 << 8;
      D.31689 = D.31688 & 16711680;
      D.31690 = D.31687 | D.31689;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31691 = D.31683 >> 24;
      token = D.31690 | D.31691;
      klass.240 = mini_get_class (method, token, generic_context);
      klass = klass.240;
      klass.144 = klass;
      if (klass.144 == 0B) goto <D.37635>; else goto <D.37637>;
      <D.37637>:
      klass.144 = klass;
      D.34697 = klass.144->exception_type;
      if (D.34697 != 0) goto <D.37635>; else goto <D.37636>;
      <D.37635>:
      klass.144 = klass;
      cfg->exception_ptr = klass.144;
      D.37638 = mini_get_debug_options ();
      D.37639 = D.37638->break_on_unverified;
      if (D.37639 != 0) goto <D.37640>; else goto load_error;
      <D.37640>:
      raise (5);
      <D.37636>:
      klass.144 = klass;
      mono_class_init (klass.144);
      goto <D.37641>;
      <D.37624>:
      D.31121 = *ip;
      D.31122 = (int) D.31121;
      klass.241 = array_access_to_klass (D.31122);
      klass = klass.241;
      <D.37641>:
      D.31240 = *sp;
      D.32922 = D.31240->type;
      if (D.32922 != 6) goto <D.37643>; else goto <D.37644>;
      <D.37643>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.37645>; else goto <D.37646>;
      <D.37645>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.37647>; else goto <D.37648>;
      <D.37647>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.37648>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.37646>:
      D.37649 = mini_get_debug_options ();
      D.37650 = D.37649->break_on_unverified;
      if (D.37650 != 0) goto <D.37651>; else goto unverified;
      <D.37651>:
      raise (5);
      <D.37644>:
      klass.144 = klass;
      emit_array_store (cfg, klass.144, sp, 1);
      D.31121 = *ip;
      if (D.31121 == 164) goto <D.37652>; else goto <D.37653>;
      <D.37652>:
      ip = ip + 5;
      goto <D.37654>;
      <D.37653>:
      ip = ip + 1;
      <D.37654>:
      inline_costs = inline_costs + 1;
      goto <D.27394>;
      <D.27947>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.37655>; else goto <D.37656>;
      <D.37655>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.37657>; else goto <D.37658>;
      <D.37657>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.37659>; else goto <D.37660>;
      <D.37659>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.37660>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.37658>:
      D.37661 = mini_get_debug_options ();
      D.37662 = D.37661->break_on_unverified;
      if (D.37662 != 0) goto <D.37663>; else goto unverified;
      <D.37663>:
      raise (5);
      <D.37656>:
      sp = sp + 18446744073709551608;
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 728;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      D.37664 = alloc_freg (cfg);
      D.37665 = (int) D.37664;
      ins->dreg = D.37665;
      ins->type = 4;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      if (D.30577 != 0B) goto <D.37666>; else goto <D.37667>;
      <D.37666>:
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      D.30577->next = ins;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      ins->prev = D.30577;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      goto <D.37668>;
      <D.37667>:
      bblock.64 = bblock;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      D.30577 = bblock.64->last_ins;
      bblock.64->code = D.30577;
      <D.37668>:
      sp.242 = sp;
      sp = sp.242 + 8;
      D.37670 = mono_decompose_opcode (cfg, ins);
      *sp.242 = D.37670;
      ip = ip + 1;
      goto <D.27394>;
      <D.27948>:
      {
        struct MonoInst * src_var;
        struct MonoInst * src;
        int klass_reg;
        int dreg;

        D.37671 = alloc_preg (cfg);
        klass_reg = (int) D.37671;
        D.37672 = alloc_preg (cfg);
        dreg = (int) D.37672;
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.37673>; else goto <D.37674>;
        <D.37673>:
        D.30178 = method->klass;
        D.31934 = D.30178->name_space;
        D.30178 = method->klass;
        D.31935 = D.30178->name;
        D.31936 = method->name;
        D.31937 = method->signature;
        D.31938 = D.31937->param_count;
        D.31939 = (int) D.31938;
        D.31121 = *ip;
        D.31122 = (int) D.31121;
        D.37675 = mono_opcode_name (D.31122);
        D.37676 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.31934, D.31935, D.31936, D.31939, D.37675, "method-to-ir.c", 10668);
        cfg->exception_message = D.37676;
        D.30322 = cfg->verbose_level;
        if (D.30322 > 1) goto <D.37677>; else goto <D.37678>;
        <D.37677>:
        D.31944 = cfg->exception_message;
        printf ("%s\n", D.31944);
        <D.37678>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.37674>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        if (D.31013 <= 7) goto <D.37679>; else goto <D.37680>;
        <D.37679>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.37681>; else goto <D.37682>;
        <D.37681>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.37683>; else goto <D.37684>;
        <D.37683>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.37684>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.37682>:
        D.37685 = mini_get_debug_options ();
        D.37686 = D.37685->break_on_unverified;
        if (D.37686 != 0) goto <D.37687>; else goto unverified;
        <D.37687>:
        raise (5);
        <D.37680>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        D.31121 = *ip;
        D.33677 = (short unsigned int) D.31121;
        ins->opcode = D.33677;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        sp = sp + 18446744073709551608;
        D.31664 = ip + 5;
        if (D.31664 > end) goto <D.37688>; else goto <D.37689>;
        <D.37688>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.37690>; else goto <D.37691>;
        <D.37690>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.37692>; else goto <D.37693>;
        <D.37692>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.37693>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.37691>:
        D.37694 = mini_get_debug_options ();
        D.37695 = D.37694->break_on_unverified;
        if (D.37695 != 0) goto <D.37696>; else goto unverified;
        <D.37696>:
        raise (5);
        <D.37689>:
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31684 = D.31683 << 24;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31685 = D.31683 >> 8;
        D.31686 = D.31685 & 65280;
        D.31687 = D.31684 | D.31686;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31688 = D.31683 << 8;
        D.31689 = D.31688 & 16711680;
        D.31690 = D.31687 | D.31689;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31691 = D.31683 >> 24;
        D.31692 = D.31690 | D.31691;
        klass.243 = mono_class_get_full (image, D.31692, generic_context);
        klass = klass.243;
        klass.144 = klass;
        if (klass.144 == 0B) goto <D.37698>; else goto <D.37700>;
        <D.37700>:
        klass.144 = klass;
        D.34697 = klass.144->exception_type;
        if (D.34697 != 0) goto <D.37698>; else goto <D.37699>;
        <D.37698>:
        klass.144 = klass;
        cfg->exception_ptr = klass.144;
        D.37701 = mini_get_debug_options ();
        D.37702 = D.37701->break_on_unverified;
        if (D.37702 != 0) goto <D.37703>; else goto load_error;
        <D.37703>:
        raise (5);
        <D.37699>:
        klass.144 = klass;
        mono_class_init (klass.144);
        klass.144 = klass;
        context_used = mini_class_check_context_used (cfg, klass.144);
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        D.36366 = (unsigned int) D.31422;
        D.31341 = cfg->vreg_to_inst_len;
        if (D.36366 < D.31341) goto <D.37705>; else goto <D.37706>;
        <D.37705>:
        D.31344 = cfg->vreg_to_inst;
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        D.36369 = (long unsigned int) D.31422;
        D.36370 = D.36369 * 8;
        D.36371 = D.31344 + D.36370;
        iftmp.244 = *D.36371;
        goto <D.37707>;
        <D.37706>:
        iftmp.244 = 0B;
        <D.37707>:
        src_var = iftmp.244;
        if (src_var == 0B) goto <D.37708>; else goto <D.37709>;
        <D.37708>:
        D.37710 = mono_defaults.typed_reference_class;
        D.37711 = &D.37710->byval_arg;
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        src_var = mono_compile_create_var_for_vreg (cfg, D.37711, 329, D.31422);
        <D.37709>:
        D.30241 = cfg->mempool;
        src = mono_mempool_alloc (D.30241, 80);
        src->data.op[1].const_val = 0;
        D.37712 = src->data.op[1].const_val;
        src->data.op[0].const_val = D.37712;
        src->prev = 0B;
        D.37713 = src->prev;
        src->next = D.37713;
        src->opcode = 314;
        src->flags = 0;
        src->type = 0;
        src->dreg = -1;
        src->sreg3 = -1;
        D.37714 = src->sreg3;
        src->sreg2 = D.37714;
        D.37715 = src->sreg2;
        src->sreg1 = D.37715;
        D.30461 = cfg->ip;
        src->cil_code = D.30461;
        src->data.op[0].p = src_var;
        D.37716 = src_var->flags;
        D.37717 = D.37716 | 16;
        src_var->flags = D.37717;
        src->type = 5;
        D.37718 = src_var->klass;
        src->klass = D.37718;
        D.37719 = alloc_dreg (cfg, 5);
        D.37720 = (int) D.37719;
        src->dreg = D.37720;
        cfg->has_indirection = 1;
        D.30389 = cfg->gsharedvt;
        D.31326 = D.30389 != 0;
        D.31327 = (long int) D.31326;
        D.31328 = __builtin_expect (D.31327, 0);
        if (D.31328 != 0) goto <D.37721>; else goto <D.37722>;
        <D.37721>:
        D.37723 = src_var->data.op[1].vtype;
        D.37724 = mini_is_gsharedvt_variable_type (cfg, D.37723);
        if (D.37724 != 0) goto <D.37725>; else goto <D.37726>;
        <D.37725>:
        handle_gsharedvt_ldaddr (cfg);
        <D.37726>:
        <D.37722>:
        if (0 != 0) goto <D.37727>; else goto <D.37728>;
        <D.37727>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.37730 = src_var->dreg;
          D.37731 = D.37730 + 1;
          D.37732 = (unsigned int) D.37731;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.37732 < D.31341) goto <D.37733>; else goto <D.37734>;
          <D.37733>:
          D.31344 = cfg->vreg_to_inst;
          D.37730 = src_var->dreg;
          D.37735 = (sizetype) D.37730;
          D.37736 = D.37735 + 1;
          D.37737 = D.37736 * 8;
          D.37738 = D.31344 + D.37737;
          iftmp.245 = *D.37738;
          goto <D.37739>;
          <D.37734>:
          iftmp.245 = 0B;
          <D.37739>:
          var1 = iftmp.245;
          D.37730 = src_var->dreg;
          D.37741 = D.37730 + 2;
          D.37742 = (unsigned int) D.37741;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.37742 < D.31341) goto <D.37743>; else goto <D.37744>;
          <D.37743>:
          D.31344 = cfg->vreg_to_inst;
          D.37730 = src_var->dreg;
          D.37735 = (sizetype) D.37730;
          D.37745 = D.37735 + 2;
          D.37746 = D.37745 * 8;
          D.37747 = D.31344 + D.37746;
          iftmp.246 = *D.37747;
          goto <D.37748>;
          <D.37744>:
          iftmp.246 = 0B;
          <D.37748>:
          var2 = iftmp.246;
          D.37749 = var1 == 0B;
          D.37750 = (long int) D.37749;
          D.37751 = __builtin_expect (D.37750, 0);
          if (D.37751 != 0) goto <D.37752>; else goto <D.37753>;
          <D.37752>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10684, "var1");
          <D.37753>:
          D.37754 = var2 == 0B;
          D.37755 = (long int) D.37754;
          D.37756 = __builtin_expect (D.37755, 0);
          if (D.37756 != 0) goto <D.37757>; else goto <D.37758>;
          <D.37757>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10684, "var2");
          <D.37758>:
          D.37759 = var1->flags;
          D.37760 = D.37759 | 16;
          var1->flags = D.37760;
          D.37761 = var2->flags;
          D.37762 = D.37761 | 16;
          var2->flags = D.37762;
        }
        <D.37728>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.37763>; else goto <D.37764>;
        <D.37763>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = src;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        src->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = src;
        goto <D.37765>;
        <D.37764>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = src;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.37765>:
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.37766 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.37766;
          inst->prev = 0B;
          D.37767 = inst->prev;
          inst->next = D.37767;
          inst->opcode = 388;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.37768 = inst->sreg3;
          inst->sreg2 = D.37768;
          D.37769 = inst->sreg2;
          inst->sreg1 = D.37769;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          inst->dreg = klass_reg;
          D.37770 = src->dreg;
          inst->sreg1 = D.37770;
          inst->data.op[0].const_val = 16;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.37771>; else goto <D.37772>;
          <D.37771>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.37773>;
          <D.37772>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.37773>:
        }
        if (context_used != 0) goto <D.37774>; else goto <D.37775>;
        <D.37774>:
        {
          struct MonoInst * klass_ins;

          klass.144 = klass;
          klass_ins = emit_get_rgctx_klass (cfg, context_used, klass.144, 1);
          {
            struct MonoInst * inst;

            D.30241 = cfg->mempool;
            inst = mono_mempool_alloc (D.30241, 80);
            inst->data.op[1].const_val = 0;
            D.37776 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.37776;
            inst->prev = 0B;
            D.37777 = inst->prev;
            inst->next = D.37777;
            inst->opcode = 322;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.37778 = inst->sreg3;
            inst->sreg2 = D.37778;
            D.37779 = inst->sreg2;
            inst->sreg1 = D.37779;
            D.30461 = cfg->ip;
            inst->cil_code = D.30461;
            inst->dreg = -1;
            inst->sreg1 = klass_reg;
            D.37780 = klass_ins->dreg;
            inst->sreg2 = D.37780;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37781>; else goto <D.37782>;
            <D.37781>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = inst;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            inst->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            goto <D.37783>;
            <D.37782>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37783>:
          }
          {
            struct MonoInst * inst;

            D.30241 = cfg->mempool;
            inst = mono_mempool_alloc (D.30241, 80);
            inst->data.op[1].const_val = 0;
            D.37784 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.37784;
            inst->prev = 0B;
            D.37785 = inst->prev;
            inst->next = D.37785;
            inst->opcode = 456;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.37786 = inst->sreg3;
            inst->sreg2 = D.37786;
            D.37787 = inst->sreg2;
            inst->sreg1 = D.37787;
            D.30461 = cfg->ip;
            inst->cil_code = D.30461;
            inst->data.op[1].p = "InvalidCastException";
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37788>; else goto <D.37789>;
            <D.37788>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = inst;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            inst->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            goto <D.37790>;
            <D.37789>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37790>:
          }
        }
        goto <D.37791>;
        <D.37775>:
        klass.144 = klass;
        mini_emit_class_check (cfg, klass_reg, klass.144);
        <D.37791>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 388;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        ins->dreg = dreg;
        D.37770 = src->dreg;
        ins->sreg1 = D.37770;
        ins->data.op[0].const_val = 8;
        ins->type = 1;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.37792>; else goto <D.37793>;
        <D.37792>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.37794>;
        <D.37793>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.37794>:
        ins->type = 5;
        sp.247 = sp;
        sp = sp.247 + 8;
        *sp.247 = ins;
        ip = ip + 5;
        goto <D.27394>;
      }
      <D.27959>:
      {
        struct MonoInst * loc;
        struct MonoInst * addr;

        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.37796>; else goto <D.37797>;
        <D.37796>:
        D.30178 = method->klass;
        D.31934 = D.30178->name_space;
        D.30178 = method->klass;
        D.31935 = D.30178->name;
        D.31936 = method->name;
        D.31937 = method->signature;
        D.31938 = D.31937->param_count;
        D.31939 = (int) D.31938;
        D.31121 = *ip;
        D.31122 = (int) D.31121;
        D.37798 = mono_opcode_name (D.31122);
        D.37799 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.31934, D.31935, D.31936, D.31939, D.37798, "method-to-ir.c", 10708);
        cfg->exception_message = D.37799;
        D.30322 = cfg->verbose_level;
        if (D.30322 > 1) goto <D.37800>; else goto <D.37801>;
        <D.37800>:
        D.31944 = cfg->exception_message;
        printf ("%s\n", D.31944);
        <D.37801>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.37797>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        if (D.31013 <= 7) goto <D.37802>; else goto <D.37803>;
        <D.37802>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.37804>; else goto <D.37805>;
        <D.37804>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.37806>; else goto <D.37807>;
        <D.37806>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.37807>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.37805>:
        D.37808 = mini_get_debug_options ();
        D.37809 = D.37808->break_on_unverified;
        if (D.37809 != 0) goto <D.37810>; else goto unverified;
        <D.37810>:
        raise (5);
        <D.37803>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        D.31121 = *ip;
        D.33677 = (short unsigned int) D.31121;
        ins->opcode = D.33677;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        sp = sp + 18446744073709551608;
        D.31664 = ip + 5;
        if (D.31664 > end) goto <D.37811>; else goto <D.37812>;
        <D.37811>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.37813>; else goto <D.37814>;
        <D.37813>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.37815>; else goto <D.37816>;
        <D.37815>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.37816>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.37814>:
        D.37817 = mini_get_debug_options ();
        D.37818 = D.37817->break_on_unverified;
        if (D.37818 != 0) goto <D.37819>; else goto unverified;
        <D.37819>:
        raise (5);
        <D.37812>:
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31684 = D.31683 << 24;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31685 = D.31683 >> 8;
        D.31686 = D.31685 & 65280;
        D.31687 = D.31684 | D.31686;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31688 = D.31683 << 8;
        D.31689 = D.31688 & 16711680;
        D.31690 = D.31687 | D.31689;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31691 = D.31683 >> 24;
        D.31692 = D.31690 | D.31691;
        klass.248 = mono_class_get_full (image, D.31692, generic_context);
        klass = klass.248;
        klass.144 = klass;
        if (klass.144 == 0B) goto <D.37821>; else goto <D.37823>;
        <D.37823>:
        klass.144 = klass;
        D.34697 = klass.144->exception_type;
        if (D.34697 != 0) goto <D.37821>; else goto <D.37822>;
        <D.37821>:
        klass.144 = klass;
        cfg->exception_ptr = klass.144;
        D.37824 = mini_get_debug_options ();
        D.37825 = D.37824->break_on_unverified;
        if (D.37825 != 0) goto <D.37826>; else goto load_error;
        <D.37826>:
        raise (5);
        <D.37822>:
        klass.144 = klass;
        mono_class_init (klass.144);
        klass.144 = klass;
        context_used = mini_class_check_context_used (cfg, klass.144);
        D.37710 = mono_defaults.typed_reference_class;
        D.37711 = &D.37710->byval_arg;
        loc = mono_compile_create_var (cfg, D.37711, 329);
        D.30241 = cfg->mempool;
        addr = mono_mempool_alloc (D.30241, 80);
        addr->data.op[1].const_val = 0;
        D.37827 = addr->data.op[1].const_val;
        addr->data.op[0].const_val = D.37827;
        addr->prev = 0B;
        D.37828 = addr->prev;
        addr->next = D.37828;
        addr->opcode = 314;
        addr->flags = 0;
        addr->type = 0;
        addr->dreg = -1;
        addr->sreg3 = -1;
        D.37829 = addr->sreg3;
        addr->sreg2 = D.37829;
        D.37830 = addr->sreg2;
        addr->sreg1 = D.37830;
        D.30461 = cfg->ip;
        addr->cil_code = D.30461;
        D.30978 = cfg->varinfo;
        D.37831 = loc->data.op[0].const_val;
        D.37832 = (long unsigned int) D.37831;
        D.37833 = D.37832 * 8;
        D.37834 = D.30978 + D.37833;
        D.37835 = *D.37834;
        addr->data.op[0].p = D.37835;
        D.30978 = cfg->varinfo;
        D.37831 = loc->data.op[0].const_val;
        D.37832 = (long unsigned int) D.37831;
        D.37833 = D.37832 * 8;
        D.37834 = D.30978 + D.37833;
        D.37835 = *D.37834;
        D.30978 = cfg->varinfo;
        D.37831 = loc->data.op[0].const_val;
        D.37832 = (long unsigned int) D.37831;
        D.37833 = D.37832 * 8;
        D.37834 = D.30978 + D.37833;
        D.37835 = *D.37834;
        D.37836 = D.37835->flags;
        D.37837 = D.37836 | 16;
        D.37835->flags = D.37837;
        addr->type = 5;
        D.30978 = cfg->varinfo;
        D.37831 = loc->data.op[0].const_val;
        D.37832 = (long unsigned int) D.37831;
        D.37833 = D.37832 * 8;
        D.37834 = D.30978 + D.37833;
        D.37835 = *D.37834;
        D.37838 = D.37835->klass;
        addr->klass = D.37838;
        D.37839 = alloc_dreg (cfg, 5);
        D.37840 = (int) D.37839;
        addr->dreg = D.37840;
        cfg->has_indirection = 1;
        D.30389 = cfg->gsharedvt;
        D.31326 = D.30389 != 0;
        D.31327 = (long int) D.31326;
        D.31328 = __builtin_expect (D.31327, 0);
        if (D.31328 != 0) goto <D.37841>; else goto <D.37842>;
        <D.37841>:
        D.30978 = cfg->varinfo;
        D.37831 = loc->data.op[0].const_val;
        D.37832 = (long unsigned int) D.37831;
        D.37833 = D.37832 * 8;
        D.37834 = D.30978 + D.37833;
        D.37835 = *D.37834;
        D.37843 = D.37835->data.op[1].vtype;
        D.37844 = mini_is_gsharedvt_variable_type (cfg, D.37843);
        if (D.37844 != 0) goto <D.37845>; else goto <D.37846>;
        <D.37845>:
        handle_gsharedvt_ldaddr (cfg);
        <D.37846>:
        <D.37842>:
        if (0 != 0) goto <D.37847>; else goto <D.37848>;
        <D.37847>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.30978 = cfg->varinfo;
          D.37831 = loc->data.op[0].const_val;
          D.37832 = (long unsigned int) D.37831;
          D.37833 = D.37832 * 8;
          D.37834 = D.30978 + D.37833;
          D.37835 = *D.37834;
          D.37850 = D.37835->dreg;
          D.37851 = D.37850 + 1;
          D.37852 = (unsigned int) D.37851;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.37852 < D.31341) goto <D.37853>; else goto <D.37854>;
          <D.37853>:
          D.31344 = cfg->vreg_to_inst;
          D.30978 = cfg->varinfo;
          D.37831 = loc->data.op[0].const_val;
          D.37832 = (long unsigned int) D.37831;
          D.37833 = D.37832 * 8;
          D.37834 = D.30978 + D.37833;
          D.37835 = *D.37834;
          D.37850 = D.37835->dreg;
          D.37855 = (sizetype) D.37850;
          D.37856 = D.37855 + 1;
          D.37857 = D.37856 * 8;
          D.37858 = D.31344 + D.37857;
          iftmp.249 = *D.37858;
          goto <D.37859>;
          <D.37854>:
          iftmp.249 = 0B;
          <D.37859>:
          var1 = iftmp.249;
          D.30978 = cfg->varinfo;
          D.37831 = loc->data.op[0].const_val;
          D.37832 = (long unsigned int) D.37831;
          D.37833 = D.37832 * 8;
          D.37834 = D.30978 + D.37833;
          D.37835 = *D.37834;
          D.37850 = D.37835->dreg;
          D.37861 = D.37850 + 2;
          D.37862 = (unsigned int) D.37861;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.37862 < D.31341) goto <D.37863>; else goto <D.37864>;
          <D.37863>:
          D.31344 = cfg->vreg_to_inst;
          D.30978 = cfg->varinfo;
          D.37831 = loc->data.op[0].const_val;
          D.37832 = (long unsigned int) D.37831;
          D.37833 = D.37832 * 8;
          D.37834 = D.30978 + D.37833;
          D.37835 = *D.37834;
          D.37850 = D.37835->dreg;
          D.37855 = (sizetype) D.37850;
          D.37865 = D.37855 + 2;
          D.37866 = D.37865 * 8;
          D.37867 = D.31344 + D.37866;
          iftmp.250 = *D.37867;
          goto <D.37868>;
          <D.37864>:
          iftmp.250 = 0B;
          <D.37868>:
          var2 = iftmp.250;
          D.37869 = var1 == 0B;
          D.37870 = (long int) D.37869;
          D.37871 = __builtin_expect (D.37870, 0);
          if (D.37871 != 0) goto <D.37872>; else goto <D.37873>;
          <D.37872>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10721, "var1");
          <D.37873>:
          D.37874 = var2 == 0B;
          D.37875 = (long int) D.37874;
          D.37876 = __builtin_expect (D.37875, 0);
          if (D.37876 != 0) goto <D.37877>; else goto <D.37878>;
          <D.37877>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10721, "var2");
          <D.37878>:
          D.37879 = var1->flags;
          D.37880 = D.37879 | 16;
          var1->flags = D.37880;
          D.37881 = var2->flags;
          D.37882 = D.37881 | 16;
          var2->flags = D.37882;
        }
        <D.37848>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.37883>; else goto <D.37884>;
        <D.37883>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = addr;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        addr->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = addr;
        goto <D.37885>;
        <D.37884>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = addr;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.37885>:
        if (context_used != 0) goto <D.37886>; else goto <D.37887>;
        <D.37886>:
        {
          struct MonoInst * const_ins;
          int type_reg;

          D.37888 = alloc_preg (cfg);
          type_reg = (int) D.37888;
          klass.144 = klass;
          const_ins = emit_get_rgctx_klass (cfg, context_used, klass.144, 1);
          {
            struct MonoInst * inst;

            D.30241 = cfg->mempool;
            inst = mono_mempool_alloc (D.30241, 80);
            inst->data.op[1].const_val = 0;
            D.37889 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.37889;
            inst->prev = 0B;
            D.37890 = inst->prev;
            inst->next = D.37890;
            inst->opcode = 378;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.37891 = inst->sreg3;
            inst->sreg2 = D.37891;
            D.37892 = inst->sreg2;
            inst->sreg1 = D.37892;
            D.30461 = cfg->ip;
            inst->cil_code = D.30461;
            D.37893 = const_ins->dreg;
            inst->sreg1 = D.37893;
            D.37894 = addr->dreg;
            inst->dreg = D.37894;
            inst->data.op[0].const_val = 16;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37895>; else goto <D.37896>;
            <D.37895>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = inst;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            inst->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            goto <D.37897>;
            <D.37896>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37897>:
          }
          {
            struct MonoInst * inst;

            D.30241 = cfg->mempool;
            inst = mono_mempool_alloc (D.30241, 80);
            inst->data.op[1].const_val = 0;
            D.37898 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.37898;
            inst->prev = 0B;
            D.37899 = inst->prev;
            inst->next = D.37899;
            inst->opcode = 429;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.37900 = inst->sreg3;
            inst->sreg2 = D.37900;
            D.37901 = inst->sreg2;
            inst->sreg1 = D.37901;
            D.30461 = cfg->ip;
            inst->cil_code = D.30461;
            inst->dreg = type_reg;
            D.37893 = const_ins->dreg;
            inst->sreg1 = D.37893;
            inst->data.op[1].const_val = 200;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37902>; else goto <D.37903>;
            <D.37902>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = inst;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            inst->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            goto <D.37904>;
            <D.37903>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37904>:
          }
          {
            struct MonoInst * inst;

            D.30241 = cfg->mempool;
            inst = mono_mempool_alloc (D.30241, 80);
            inst->data.op[1].const_val = 0;
            D.37905 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.37905;
            inst->prev = 0B;
            D.37906 = inst->prev;
            inst->next = D.37906;
            inst->opcode = 378;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.37907 = inst->sreg3;
            inst->sreg2 = D.37907;
            D.37908 = inst->sreg2;
            inst->sreg1 = D.37908;
            D.30461 = cfg->ip;
            inst->cil_code = D.30461;
            inst->sreg1 = type_reg;
            D.37894 = addr->dreg;
            inst->dreg = D.37894;
            inst->data.op[0].const_val = 0;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37909>; else goto <D.37910>;
            <D.37909>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = inst;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            inst->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            goto <D.37911>;
            <D.37910>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37911>:
          }
        }
        goto <D.37912>;
        <D.37887>:
        D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.30635 = D.30634 & 33554432;
        if (D.30635 != 0) goto <D.37913>; else goto <D.37914>;
        <D.37913>:
        {
          int const_reg;
          int type_reg;

          D.37915 = alloc_preg (cfg);
          const_reg = (int) D.37915;
          D.37916 = alloc_preg (cfg);
          type_reg = (int) D.37916;
          {
            struct MonoInst * inst;

            D.30241 = cfg->mempool;
            inst = mono_mempool_alloc (D.30241, 80);
            inst->data.op[1].const_val = 0;
            D.37917 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.37917;
            inst->prev = 0B;
            D.37918 = inst->prev;
            inst->next = D.37918;
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.37920>; else goto <D.37921>;
            <D.37920>:
            iftmp.251 = 732;
            goto <D.37922>;
            <D.37921>:
            iftmp.251 = 363;
            <D.37922>:
            inst->opcode = iftmp.251;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.37923 = inst->sreg3;
            inst->sreg2 = D.37923;
            D.37924 = inst->sreg2;
            inst->sreg1 = D.37924;
            D.30461 = cfg->ip;
            inst->cil_code = D.30461;
            inst->dreg = const_reg;
            klass.144 = klass;
            inst->data.op[0].p = klass.144;
            inst->data.op[1].const_val = 11;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37925>; else goto <D.37926>;
            <D.37925>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = inst;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            inst->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            goto <D.37927>;
            <D.37926>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37927>:
          }
          {
            struct MonoInst * inst;

            D.30241 = cfg->mempool;
            inst = mono_mempool_alloc (D.30241, 80);
            inst->data.op[1].const_val = 0;
            D.37928 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.37928;
            inst->prev = 0B;
            D.37929 = inst->prev;
            inst->next = D.37929;
            inst->opcode = 378;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.37930 = inst->sreg3;
            inst->sreg2 = D.37930;
            D.37931 = inst->sreg2;
            inst->sreg1 = D.37931;
            D.30461 = cfg->ip;
            inst->cil_code = D.30461;
            inst->sreg1 = const_reg;
            D.37894 = addr->dreg;
            inst->dreg = D.37894;
            inst->data.op[0].const_val = 16;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37932>; else goto <D.37933>;
            <D.37932>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = inst;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            inst->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            goto <D.37934>;
            <D.37933>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37934>:
          }
          {
            struct MonoInst * inst;

            D.30241 = cfg->mempool;
            inst = mono_mempool_alloc (D.30241, 80);
            inst->data.op[1].const_val = 0;
            D.37935 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.37935;
            inst->prev = 0B;
            D.37936 = inst->prev;
            inst->next = D.37936;
            inst->opcode = 429;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.37937 = inst->sreg3;
            inst->sreg2 = D.37937;
            D.37938 = inst->sreg2;
            inst->sreg1 = D.37938;
            D.30461 = cfg->ip;
            inst->cil_code = D.30461;
            inst->dreg = type_reg;
            inst->sreg1 = const_reg;
            inst->data.op[1].const_val = 200;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37939>; else goto <D.37940>;
            <D.37939>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = inst;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            inst->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            goto <D.37941>;
            <D.37940>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37941>:
          }
          {
            struct MonoInst * inst;

            D.30241 = cfg->mempool;
            inst = mono_mempool_alloc (D.30241, 80);
            inst->data.op[1].const_val = 0;
            D.37942 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.37942;
            inst->prev = 0B;
            D.37943 = inst->prev;
            inst->next = D.37943;
            inst->opcode = 378;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.37944 = inst->sreg3;
            inst->sreg2 = D.37944;
            D.37945 = inst->sreg2;
            inst->sreg1 = D.37945;
            D.30461 = cfg->ip;
            inst->cil_code = D.30461;
            inst->sreg1 = type_reg;
            D.37894 = addr->dreg;
            inst->dreg = D.37894;
            inst->data.op[0].const_val = 0;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.37946>; else goto <D.37947>;
            <D.37946>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = inst;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            inst->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            goto <D.37948>;
            <D.37947>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = inst;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.37948>:
          }
        }
        goto <D.37949>;
        <D.37914>:
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.37950 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.37950;
          inst->prev = 0B;
          D.37951 = inst->prev;
          inst->next = D.37951;
          inst->opcode = 385;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.37952 = inst->sreg3;
          inst->sreg2 = D.37952;
          D.37953 = inst->sreg2;
          inst->sreg1 = D.37953;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          D.37894 = addr->dreg;
          inst->dreg = D.37894;
          inst->data.op[0].const_val = 0;
          klass.144 = klass;
          D.34771 = &klass.144->byval_arg;
          D.37954 = (long int) D.34771;
          inst->data.op[1].const_val = D.37954;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.37955>; else goto <D.37956>;
          <D.37955>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.37957>;
          <D.37956>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.37957>:
        }
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.37958 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.37958;
          inst->prev = 0B;
          D.37959 = inst->prev;
          inst->next = D.37959;
          inst->opcode = 385;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.37960 = inst->sreg3;
          inst->sreg2 = D.37960;
          D.37961 = inst->sreg2;
          inst->sreg1 = D.37961;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          D.37894 = addr->dreg;
          inst->dreg = D.37894;
          inst->data.op[0].const_val = 16;
          klass.144 = klass;
          klass.252 = (long int) klass.144;
          inst->data.op[1].const_val = klass.252;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.37963>; else goto <D.37964>;
          <D.37963>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.37965>;
          <D.37964>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.37965>:
        }
        <D.37949>:
        <D.37912>:
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.37966 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.37966;
          inst->prev = 0B;
          D.37967 = inst->prev;
          inst->next = D.37967;
          inst->opcode = 378;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.37968 = inst->sreg3;
          inst->sreg2 = D.37968;
          D.37969 = inst->sreg2;
          inst->sreg1 = D.37969;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          D.31240 = *sp;
          D.31422 = D.31240->dreg;
          inst->sreg1 = D.31422;
          D.37894 = addr->dreg;
          inst->dreg = D.37894;
          inst->data.op[0].const_val = 8;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.37970>; else goto <D.37971>;
          <D.37970>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.37972>;
          <D.37971>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.37972>:
        }
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 424;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        D.30978 = cfg->varinfo;
        D.37831 = loc->data.op[0].const_val;
        D.37832 = (long unsigned int) D.37831;
        D.37833 = D.37832 * 8;
        D.37834 = D.30978 + D.37833;
        D.37835 = *D.37834;
        D.37843 = D.37835->data.op[1].vtype;
        D.37973 = mono_type_to_regmove (cfg, D.37843);
        D.37974 = (short unsigned int) D.37973;
        ins->opcode = D.37974;
        D.30978 = cfg->varinfo;
        D.37831 = loc->data.op[0].const_val;
        D.37832 = (long unsigned int) D.37831;
        D.37833 = D.37832 * 8;
        D.37834 = D.30978 + D.37833;
        D.37835 = *D.37834;
        D.37843 = D.37835->data.op[1].vtype;
        type_to_eval_stack_type (cfg, D.37843, ins);
        D.30978 = cfg->varinfo;
        D.37831 = loc->data.op[0].const_val;
        D.37832 = (long unsigned int) D.37831;
        D.37833 = D.37832 * 8;
        D.37834 = D.30978 + D.37833;
        D.37835 = *D.37834;
        D.37838 = D.37835->klass;
        ins->klass = D.37838;
        D.30978 = cfg->varinfo;
        D.37831 = loc->data.op[0].const_val;
        D.37832 = (long unsigned int) D.37831;
        D.37833 = D.37832 * 8;
        D.37834 = D.30978 + D.37833;
        D.37835 = *D.37834;
        D.37850 = D.37835->dreg;
        ins->sreg1 = D.37850;
        D.30988 = ins->type;
        D.30989 = (<unnamed type>) D.30988;
        D.37975 = alloc_dreg (cfg, D.30989);
        D.37976 = (int) D.37975;
        ins->dreg = D.37976;
        D.30992 = ins->opcode;
        if (D.30992 == 427) goto <D.37977>; else goto <D.37978>;
        <D.37977>:
        D.30978 = cfg->varinfo;
        D.37831 = loc->data.op[0].const_val;
        D.37832 = (long unsigned int) D.37831;
        D.37833 = D.37832 * 8;
        D.37834 = D.30978 + D.37833;
        D.37835 = *D.37834;
        D.37843 = D.37835->data.op[1].vtype;
        D.37979 = mono_class_from_mono_type (D.37843);
        ins->klass = D.37979;
        <D.37978>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.37980>; else goto <D.37981>;
        <D.37980>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.37982>;
        <D.37981>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.37982>:
        ins->type = 7;
        D.37710 = mono_defaults.typed_reference_class;
        ins->klass = D.37710;
        sp.253 = sp;
        sp = sp.253 + 8;
        *sp.253 = ins;
        ip = ip + 5;
        goto <D.27394>;
      }
      <D.27978>:
      {
        void * handle;
        struct MonoClass * handle_class;

        try
          {
            sp.71 = (long int) sp;
            stack_start.72 = (long int) stack_start;
            D.31013 = sp.71 - stack_start.72;
            D.31014 = D.31013 /[ex] 8;
            D.30924 = header->max_stack;
            D.31146 = (long int) D.30924;
            if (D.31014 >= D.31146) goto <D.37984>; else goto <D.37985>;
            <D.37984>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.37986>; else goto <D.37987>;
            <D.37986>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.37988>; else goto <D.37989>;
            <D.37988>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.37989>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.37987>:
            D.37990 = mini_get_debug_options ();
            D.37991 = D.37990->break_on_unverified;
            if (D.37991 != 0) goto <D.37992>; else goto unverified;
            <D.37992>:
            raise (5);
            <D.37985>:
            D.31664 = ip + 5;
            if (D.31664 > end) goto <D.37993>; else goto <D.37994>;
            <D.37993>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.37995>; else goto <D.37996>;
            <D.37995>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.37997>; else goto <D.37998>;
            <D.37997>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.37998>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.37996>:
            D.37999 = mini_get_debug_options ();
            D.38000 = D.37999->break_on_unverified;
            if (D.38000 != 0) goto <D.38001>; else goto unverified;
            <D.38001>:
            raise (5);
            <D.37994>:
            D.31270 = ip + 1;
            D.31683 = MEM[(const guint32 *)D.31270];
            D.31684 = D.31683 << 24;
            D.31270 = ip + 1;
            D.31683 = MEM[(const guint32 *)D.31270];
            D.31685 = D.31683 >> 8;
            D.31686 = D.31685 & 65280;
            D.31687 = D.31684 | D.31686;
            D.31270 = ip + 1;
            D.31683 = MEM[(const guint32 *)D.31270];
            D.31688 = D.31683 << 8;
            D.31689 = D.31688 & 16711680;
            D.31690 = D.31687 | D.31689;
            D.31270 = ip + 1;
            D.31683 = MEM[(const guint32 *)D.31270];
            D.31691 = D.31683 >> 24;
            D.31692 = D.31690 | D.31691;
            n = (int) D.31692;
            D.30183 = BIT_FIELD_REF <*method, 64, 256>;
            D.30184 = D.30183 & 4467570830351532032;
            if (D.30184 == 2449958197289549824) goto <D.38002>; else goto <D.38005>;
            <D.38005>:
            D.30183 = BIT_FIELD_REF <*method, 64, 256>;
            D.30184 = D.30183 & 4467570830351532032;
            if (D.30184 == 2305843009213693952) goto <D.38002>; else goto <D.38003>;
            <D.38002>:
            n.148 = (unsigned int) n;
            handle = mono_method_get_wrapper_data (method, n.148);
            D.38006 = n + 1;
            D.38007 = (unsigned int) D.38006;
            handle_class.254 = mono_method_get_wrapper_data (method, D.38007);
            handle_class = handle_class.254;
            D.38009 = mono_defaults.typehandle_class;
            handle_class.255 = handle_class;
            if (D.38009 == handle_class.255) goto <D.38011>; else goto <D.38012>;
            <D.38011>:
            handle = &MEM[(struct MonoClass *)handle].byval_arg;
            <D.38012>:
            goto <D.38004>;
            <D.38003>:
            n.150 = (unsigned int) n;
            handle = mono_ldtoken (image, n.150, &handle_class, generic_context);
            <D.38004>:
            if (handle == 0B) goto <D.38013>; else goto <D.38014>;
            <D.38013>:
            D.38015 = mini_get_debug_options ();
            D.38016 = D.38015->break_on_unverified;
            if (D.38016 != 0) goto <D.38017>; else goto load_error;
            <D.38017>:
            raise (5);
            <D.38014>:
            handle_class.255 = handle_class;
            mono_class_init (handle_class.255);
            D.30278 = cfg->generic_sharing_context;
            if (D.30278 != 0B) goto <D.38018>; else goto <D.38019>;
            <D.38018>:
            D.38020 = n >> 24;
            D.38021 = (unsigned int) D.38020;
            D.38022 = D.38021 + 4294967295;
            if (D.38022 <= 1) goto <D.38023>; else goto <D.38024>;
            <D.38023>:
            context_used = 0;
            goto <D.38025>;
            <D.38024>:
            D.38009 = mono_defaults.typehandle_class;
            handle_class.255 = handle_class;
            if (D.38009 == handle_class.255) goto <D.38026>; else goto <D.38027>;
            <D.38026>:
            D.38028 = mono_type_get_type (handle);
            if (D.38028 == 18) goto <D.38029>; else goto <D.38030>;
            <D.38029>:
            context_used = 0;
            goto <D.38031>;
            <D.38030>:
            D.38032 = mono_class_from_mono_type (handle);
            context_used = mini_class_check_context_used (cfg, D.38032);
            <D.38031>:
            goto <D.38033>;
            <D.38027>:
            D.38034 = mono_defaults.fieldhandle_class;
            handle_class.255 = handle_class;
            if (D.38034 == handle_class.255) goto <D.38035>; else goto <D.38036>;
            <D.38035>:
            D.38037 = MEM[(struct MonoClassField *)handle].parent;
            context_used = mini_class_check_context_used (cfg, D.38037);
            goto <D.38038>;
            <D.38036>:
            D.38039 = mono_defaults.methodhandle_class;
            handle_class.255 = handle_class;
            if (D.38039 == handle_class.255) goto <D.38040>; else goto <D.38041>;
            <D.38040>:
            context_used = mini_method_check_context_used (cfg, handle);
            goto <D.38042>;
            <D.38041>:
            monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 10795);
            <D.38042>:
            <D.38038>:
            <D.38033>:
            <D.38025>:
            <D.38019>:
            D.30632 = cfg->opt;
            D.30633 = D.30632 & 512;
            if (D.30633 != 0) goto <D.38045>; else goto <D.38043>;
            <D.38045>:
            D.30183 = BIT_FIELD_REF <*method, 64, 256>;
            D.30184 = D.30183 & 4467570830351532032;
            if (D.30184 != 2449958197289549824) goto <D.38046>; else goto <D.38043>;
            <D.38046>:
            D.30183 = BIT_FIELD_REF <*method, 64, 256>;
            D.30184 = D.30183 & 4467570830351532032;
            if (D.30184 != 2305843009213693952) goto <D.38047>; else goto <D.38043>;
            <D.38047>:
            {
              struct MonoInst * addr;
              struct MonoInst * vtvar;
              struct MonoInst * iargs[3];
              int method_context_used;

              try
                {
                  method_context_used = mini_method_check_context_used (cfg, method);
                  handle_class.255 = handle_class;
                  D.38048 = &handle_class.255->byval_arg;
                  vtvar = mono_compile_create_var (cfg, D.38048, 329);
                  D.30241 = cfg->mempool;
                  D.38049 = mono_mempool_alloc (D.30241, 80);
                  iargs[0] = D.38049;
                  D.38050 = iargs[0];
                  D.38050 = iargs[0];
                  D.38050->data.op[1].const_val = 0;
                  D.38051 = D.38050->data.op[1].const_val;
                  D.38050->data.op[0].const_val = D.38051;
                  D.38050 = iargs[0];
                  D.38050 = iargs[0];
                  D.38050->prev = 0B;
                  D.38052 = D.38050->prev;
                  D.38050->next = D.38052;
                  D.38050 = iargs[0];
                  D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
                  D.30635 = D.30634 & 33554432;
                  if (D.30635 != 0) goto <D.38054>; else goto <D.38055>;
                  <D.38054>:
                  iftmp.256 = 732;
                  goto <D.38056>;
                  <D.38055>:
                  iftmp.256 = 363;
                  <D.38056>:
                  D.38050->opcode = iftmp.256;
                  D.38050 = iargs[0];
                  D.38050->flags = 0;
                  D.38050 = iargs[0];
                  D.38050->type = 0;
                  D.38050 = iargs[0];
                  D.38050->dreg = -1;
                  D.38050 = iargs[0];
                  D.38050 = iargs[0];
                  D.38050 = iargs[0];
                  D.38050->sreg3 = -1;
                  D.38057 = D.38050->sreg3;
                  D.38050->sreg2 = D.38057;
                  D.38058 = D.38050->sreg2;
                  D.38050->sreg1 = D.38058;
                  D.38050 = iargs[0];
                  D.30461 = cfg->ip;
                  D.38050->cil_code = D.30461;
                  D.38050 = iargs[0];
                  D.38050->data.op[0].p = image;
                  D.38050 = iargs[0];
                  D.38050->data.op[1].src = 12B;
                  D.38050 = iargs[0];
                  D.38050->type = 3;
                  D.38050 = iargs[0];
                  D.38059 = alloc_dreg (cfg, 3);
                  D.38060 = (int) D.38059;
                  D.38050->dreg = D.38060;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.38061>; else goto <D.38062>;
                  <D.38061>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.38050 = iargs[0];
                  D.30490->next = D.38050;
                  D.38050 = iargs[0];
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.38050->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  D.38050 = iargs[0];
                  bblock.106->last_ins = D.38050;
                  goto <D.38063>;
                  <D.38062>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  D.38050 = iargs[0];
                  bblock.106->last_ins = D.38050;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.38063>:
                  D.30241 = cfg->mempool;
                  D.38064 = mono_mempool_alloc (D.30241, 80);
                  iargs[1] = D.38064;
                  D.38065 = iargs[1];
                  D.38065 = iargs[1];
                  D.38065->data.op[1].const_val = 0;
                  D.38066 = D.38065->data.op[1].const_val;
                  D.38065->data.op[0].const_val = D.38066;
                  D.38065 = iargs[1];
                  D.38065 = iargs[1];
                  D.38065->prev = 0B;
                  D.38067 = D.38065->prev;
                  D.38065->next = D.38067;
                  D.38065 = iargs[1];
                  D.38065->opcode = 362;
                  D.38065 = iargs[1];
                  D.38065->flags = 0;
                  D.38065 = iargs[1];
                  D.38065->type = 0;
                  D.38065 = iargs[1];
                  D.38065->dreg = -1;
                  D.38065 = iargs[1];
                  D.38065 = iargs[1];
                  D.38065 = iargs[1];
                  D.38065->sreg3 = -1;
                  D.38068 = D.38065->sreg3;
                  D.38065->sreg2 = D.38068;
                  D.38069 = D.38065->sreg2;
                  D.38065->sreg1 = D.38069;
                  D.38065 = iargs[1];
                  D.30461 = cfg->ip;
                  D.38065->cil_code = D.30461;
                  D.38065 = iargs[1];
                  D.34928 = (long int) n;
                  D.38065->data.op[0].const_val = D.34928;
                  D.38065 = iargs[1];
                  D.38065->type = 1;
                  D.38065 = iargs[1];
                  D.38070 = alloc_dreg (cfg, 1);
                  D.38071 = (int) D.38070;
                  D.38065->dreg = D.38071;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.38072>; else goto <D.38073>;
                  <D.38072>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.38065 = iargs[1];
                  D.30490->next = D.38065;
                  D.38065 = iargs[1];
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.38065->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  D.38065 = iargs[1];
                  bblock.106->last_ins = D.38065;
                  goto <D.38074>;
                  <D.38073>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  D.38065 = iargs[1];
                  bblock.106->last_ins = D.38065;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.38074>:
                  if (method_context_used != 0) goto <D.38075>; else goto <D.38076>;
                  <D.38075>:
                  D.38077 = emit_get_rgctx_method (cfg, method_context_used, method, 5);
                  iargs[2] = D.38077;
                  ins = mono_emit_jit_icall (cfg, mono_ldtoken_wrapper_generic_shared, &iargs);
                  goto <D.38078>;
                  <D.38076>:
                  D.30241 = cfg->mempool;
                  D.38079 = mono_mempool_alloc (D.30241, 80);
                  iargs[2] = D.38079;
                  D.38080 = iargs[2];
                  D.38080 = iargs[2];
                  D.38080->data.op[1].const_val = 0;
                  D.38081 = D.38080->data.op[1].const_val;
                  D.38080->data.op[0].const_val = D.38081;
                  D.38080 = iargs[2];
                  D.38080 = iargs[2];
                  D.38080->prev = 0B;
                  D.38082 = D.38080->prev;
                  D.38080->next = D.38082;
                  D.38080 = iargs[2];
                  D.38080->opcode = 363;
                  D.38080 = iargs[2];
                  D.38080->flags = 0;
                  D.38080 = iargs[2];
                  D.38080->type = 0;
                  D.38080 = iargs[2];
                  D.38080->dreg = -1;
                  D.38080 = iargs[2];
                  D.38080 = iargs[2];
                  D.38080 = iargs[2];
                  D.38080->sreg3 = -1;
                  D.38083 = D.38080->sreg3;
                  D.38080->sreg2 = D.38083;
                  D.38084 = D.38080->sreg2;
                  D.38080->sreg1 = D.38084;
                  D.38080 = iargs[2];
                  D.30461 = cfg->ip;
                  D.38080->cil_code = D.30461;
                  D.38080 = iargs[2];
                  D.38080->data.op[0].p = generic_context;
                  D.38080 = iargs[2];
                  D.38080->type = 3;
                  D.38080 = iargs[2];
                  D.38085 = alloc_dreg (cfg, 3);
                  D.38086 = (int) D.38085;
                  D.38080->dreg = D.38086;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.38087>; else goto <D.38088>;
                  <D.38087>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.38080 = iargs[2];
                  D.30490->next = D.38080;
                  D.38080 = iargs[2];
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.38080->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  D.38080 = iargs[2];
                  bblock.106->last_ins = D.38080;
                  goto <D.38089>;
                  <D.38088>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  D.38080 = iargs[2];
                  bblock.106->last_ins = D.38080;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.38089>:
                  ins = mono_emit_jit_icall (cfg, mono_ldtoken_wrapper, &iargs);
                  <D.38078>:
                  D.30241 = cfg->mempool;
                  addr = mono_mempool_alloc (D.30241, 80);
                  addr->data.op[1].const_val = 0;
                  D.38090 = addr->data.op[1].const_val;
                  addr->data.op[0].const_val = D.38090;
                  addr->prev = 0B;
                  D.38091 = addr->prev;
                  addr->next = D.38091;
                  addr->opcode = 314;
                  addr->flags = 0;
                  addr->type = 0;
                  addr->dreg = -1;
                  addr->sreg3 = -1;
                  D.38092 = addr->sreg3;
                  addr->sreg2 = D.38092;
                  D.38093 = addr->sreg2;
                  addr->sreg1 = D.38093;
                  D.30461 = cfg->ip;
                  addr->cil_code = D.30461;
                  D.30978 = cfg->varinfo;
                  D.38094 = vtvar->data.op[0].const_val;
                  D.38095 = (long unsigned int) D.38094;
                  D.38096 = D.38095 * 8;
                  D.38097 = D.30978 + D.38096;
                  D.38098 = *D.38097;
                  addr->data.op[0].p = D.38098;
                  D.30978 = cfg->varinfo;
                  D.38094 = vtvar->data.op[0].const_val;
                  D.38095 = (long unsigned int) D.38094;
                  D.38096 = D.38095 * 8;
                  D.38097 = D.30978 + D.38096;
                  D.38098 = *D.38097;
                  D.30978 = cfg->varinfo;
                  D.38094 = vtvar->data.op[0].const_val;
                  D.38095 = (long unsigned int) D.38094;
                  D.38096 = D.38095 * 8;
                  D.38097 = D.30978 + D.38096;
                  D.38098 = *D.38097;
                  D.38099 = D.38098->flags;
                  D.38100 = D.38099 | 16;
                  D.38098->flags = D.38100;
                  addr->type = 5;
                  D.30978 = cfg->varinfo;
                  D.38094 = vtvar->data.op[0].const_val;
                  D.38095 = (long unsigned int) D.38094;
                  D.38096 = D.38095 * 8;
                  D.38097 = D.30978 + D.38096;
                  D.38098 = *D.38097;
                  D.38101 = D.38098->klass;
                  addr->klass = D.38101;
                  D.38102 = alloc_dreg (cfg, 5);
                  D.38103 = (int) D.38102;
                  addr->dreg = D.38103;
                  cfg->has_indirection = 1;
                  D.30389 = cfg->gsharedvt;
                  D.31326 = D.30389 != 0;
                  D.31327 = (long int) D.31326;
                  D.31328 = __builtin_expect (D.31327, 0);
                  if (D.31328 != 0) goto <D.38104>; else goto <D.38105>;
                  <D.38104>:
                  D.30978 = cfg->varinfo;
                  D.38094 = vtvar->data.op[0].const_val;
                  D.38095 = (long unsigned int) D.38094;
                  D.38096 = D.38095 * 8;
                  D.38097 = D.30978 + D.38096;
                  D.38098 = *D.38097;
                  D.38106 = D.38098->data.op[1].vtype;
                  D.38107 = mini_is_gsharedvt_variable_type (cfg, D.38106);
                  if (D.38107 != 0) goto <D.38108>; else goto <D.38109>;
                  <D.38108>:
                  handle_gsharedvt_ldaddr (cfg);
                  <D.38109>:
                  <D.38105>:
                  if (0 != 0) goto <D.38110>; else goto <D.38111>;
                  <D.38110>:
                  {
                    struct MonoInst * var1;
                    struct MonoInst * var2;

                    D.30978 = cfg->varinfo;
                    D.38094 = vtvar->data.op[0].const_val;
                    D.38095 = (long unsigned int) D.38094;
                    D.38096 = D.38095 * 8;
                    D.38097 = D.30978 + D.38096;
                    D.38098 = *D.38097;
                    D.38113 = D.38098->dreg;
                    D.38114 = D.38113 + 1;
                    D.38115 = (unsigned int) D.38114;
                    D.31341 = cfg->vreg_to_inst_len;
                    if (D.38115 < D.31341) goto <D.38116>; else goto <D.38117>;
                    <D.38116>:
                    D.31344 = cfg->vreg_to_inst;
                    D.30978 = cfg->varinfo;
                    D.38094 = vtvar->data.op[0].const_val;
                    D.38095 = (long unsigned int) D.38094;
                    D.38096 = D.38095 * 8;
                    D.38097 = D.30978 + D.38096;
                    D.38098 = *D.38097;
                    D.38113 = D.38098->dreg;
                    D.38118 = (sizetype) D.38113;
                    D.38119 = D.38118 + 1;
                    D.38120 = D.38119 * 8;
                    D.38121 = D.31344 + D.38120;
                    iftmp.257 = *D.38121;
                    goto <D.38122>;
                    <D.38117>:
                    iftmp.257 = 0B;
                    <D.38122>:
                    var1 = iftmp.257;
                    D.30978 = cfg->varinfo;
                    D.38094 = vtvar->data.op[0].const_val;
                    D.38095 = (long unsigned int) D.38094;
                    D.38096 = D.38095 * 8;
                    D.38097 = D.30978 + D.38096;
                    D.38098 = *D.38097;
                    D.38113 = D.38098->dreg;
                    D.38124 = D.38113 + 2;
                    D.38125 = (unsigned int) D.38124;
                    D.31341 = cfg->vreg_to_inst_len;
                    if (D.38125 < D.31341) goto <D.38126>; else goto <D.38127>;
                    <D.38126>:
                    D.31344 = cfg->vreg_to_inst;
                    D.30978 = cfg->varinfo;
                    D.38094 = vtvar->data.op[0].const_val;
                    D.38095 = (long unsigned int) D.38094;
                    D.38096 = D.38095 * 8;
                    D.38097 = D.30978 + D.38096;
                    D.38098 = *D.38097;
                    D.38113 = D.38098->dreg;
                    D.38118 = (sizetype) D.38113;
                    D.38128 = D.38118 + 2;
                    D.38129 = D.38128 * 8;
                    D.38130 = D.31344 + D.38129;
                    iftmp.258 = *D.38130;
                    goto <D.38131>;
                    <D.38127>:
                    iftmp.258 = 0B;
                    <D.38131>:
                    var2 = iftmp.258;
                    D.38132 = var1 == 0B;
                    D.38133 = (long int) D.38132;
                    D.38134 = __builtin_expect (D.38133, 0);
                    if (D.38134 != 0) goto <D.38135>; else goto <D.38136>;
                    <D.38135>:
                    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10818, "var1");
                    <D.38136>:
                    D.38137 = var2 == 0B;
                    D.38138 = (long int) D.38137;
                    D.38139 = __builtin_expect (D.38138, 0);
                    if (D.38139 != 0) goto <D.38140>; else goto <D.38141>;
                    <D.38140>:
                    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10818, "var2");
                    <D.38141>:
                    D.38142 = var1->flags;
                    D.38143 = D.38142 | 16;
                    var1->flags = D.38143;
                    D.38144 = var2->flags;
                    D.38145 = D.38144 | 16;
                    var2->flags = D.38145;
                  }
                  <D.38111>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.38146>; else goto <D.38147>;
                  <D.38146>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.30490->next = addr;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  addr->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  bblock.106->last_ins = addr;
                  goto <D.38148>;
                  <D.38147>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  bblock.106->last_ins = addr;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.38148>:
                  {
                    struct MonoInst * inst;

                    D.30241 = cfg->mempool;
                    inst = mono_mempool_alloc (D.30241, 80);
                    inst->data.op[1].const_val = 0;
                    D.38149 = inst->data.op[1].const_val;
                    inst->data.op[0].const_val = D.38149;
                    inst->prev = 0B;
                    D.38150 = inst->prev;
                    inst->next = D.38150;
                    inst->opcode = 374;
                    inst->flags = 0;
                    inst->type = 0;
                    inst->dreg = -1;
                    inst->sreg3 = -1;
                    D.38151 = inst->sreg3;
                    inst->sreg2 = D.38151;
                    D.38152 = inst->sreg2;
                    inst->sreg1 = D.38152;
                    D.30461 = cfg->ip;
                    inst->cil_code = D.30461;
                    D.30654 = ins->dreg;
                    inst->sreg1 = D.30654;
                    D.38153 = addr->dreg;
                    inst->dreg = D.38153;
                    inst->data.op[0].const_val = 0;
                    bblock.106 = cfg->cbb;
                    D.30490 = bblock.106->last_ins;
                    if (D.30490 != 0B) goto <D.38154>; else goto <D.38155>;
                    <D.38154>:
                    bblock.106 = cfg->cbb;
                    D.30490 = bblock.106->last_ins;
                    D.30490->next = inst;
                    bblock.106 = cfg->cbb;
                    D.30490 = bblock.106->last_ins;
                    inst->prev = D.30490;
                    bblock.106 = cfg->cbb;
                    bblock.106->last_ins = inst;
                    goto <D.38156>;
                    <D.38155>:
                    bblock.106 = cfg->cbb;
                    bblock.106 = cfg->cbb;
                    bblock.106->last_ins = inst;
                    D.30490 = bblock.106->last_ins;
                    bblock.106->code = D.30490;
                    <D.38156>:
                  }
                  D.30241 = cfg->mempool;
                  ins = mono_mempool_alloc (D.30241, 80);
                  ins->data.op[1].const_val = 0;
                  D.30457 = ins->data.op[1].const_val;
                  ins->data.op[0].const_val = D.30457;
                  ins->prev = 0B;
                  D.30458 = ins->prev;
                  ins->next = D.30458;
                  ins->opcode = 424;
                  ins->flags = 0;
                  ins->type = 0;
                  ins->dreg = -1;
                  ins->sreg3 = -1;
                  D.30459 = ins->sreg3;
                  ins->sreg2 = D.30459;
                  D.30460 = ins->sreg2;
                  ins->sreg1 = D.30460;
                  D.30461 = cfg->ip;
                  ins->cil_code = D.30461;
                  D.30978 = cfg->varinfo;
                  D.38094 = vtvar->data.op[0].const_val;
                  D.38095 = (long unsigned int) D.38094;
                  D.38096 = D.38095 * 8;
                  D.38097 = D.30978 + D.38096;
                  D.38098 = *D.38097;
                  D.38106 = D.38098->data.op[1].vtype;
                  D.38157 = mono_type_to_regmove (cfg, D.38106);
                  D.38158 = (short unsigned int) D.38157;
                  ins->opcode = D.38158;
                  D.30978 = cfg->varinfo;
                  D.38094 = vtvar->data.op[0].const_val;
                  D.38095 = (long unsigned int) D.38094;
                  D.38096 = D.38095 * 8;
                  D.38097 = D.30978 + D.38096;
                  D.38098 = *D.38097;
                  D.38106 = D.38098->data.op[1].vtype;
                  type_to_eval_stack_type (cfg, D.38106, ins);
                  D.30978 = cfg->varinfo;
                  D.38094 = vtvar->data.op[0].const_val;
                  D.38095 = (long unsigned int) D.38094;
                  D.38096 = D.38095 * 8;
                  D.38097 = D.30978 + D.38096;
                  D.38098 = *D.38097;
                  D.38101 = D.38098->klass;
                  ins->klass = D.38101;
                  D.30978 = cfg->varinfo;
                  D.38094 = vtvar->data.op[0].const_val;
                  D.38095 = (long unsigned int) D.38094;
                  D.38096 = D.38095 * 8;
                  D.38097 = D.30978 + D.38096;
                  D.38098 = *D.38097;
                  D.38113 = D.38098->dreg;
                  ins->sreg1 = D.38113;
                  D.30988 = ins->type;
                  D.30989 = (<unnamed type>) D.30988;
                  D.38159 = alloc_dreg (cfg, D.30989);
                  D.38160 = (int) D.38159;
                  ins->dreg = D.38160;
                  D.30992 = ins->opcode;
                  if (D.30992 == 427) goto <D.38161>; else goto <D.38162>;
                  <D.38161>:
                  D.30978 = cfg->varinfo;
                  D.38094 = vtvar->data.op[0].const_val;
                  D.38095 = (long unsigned int) D.38094;
                  D.38096 = D.38095 * 8;
                  D.38097 = D.30978 + D.38096;
                  D.38098 = *D.38097;
                  D.38106 = D.38098->data.op[1].vtype;
                  D.38163 = mono_class_from_mono_type (D.38106);
                  ins->klass = D.38163;
                  <D.38162>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.38164>; else goto <D.38165>;
                  <D.38164>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.30490->next = ins;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  ins->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  bblock.106->last_ins = ins;
                  goto <D.38166>;
                  <D.38165>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  bblock.106->last_ins = ins;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.38166>:
                }
              finally
                {
                  iargs = {CLOBBER};
                }
            }
            goto <D.38044>;
            <D.38043>:
            D.31664 = ip + 5;
            if (D.31664 < end) goto <D.38170>; else goto <D.38167>;
            <D.38170>:
            bblock.64 = bblock;
            D.31664 = ip + 5;
            D.38171 = ip_in_bb (cfg, bblock.64, D.31664);
            if (D.38171 != 0) goto <D.38172>; else goto <D.38167>;
            <D.38172>:
            D.31664 = ip + 5;
            D.32220 = *D.31664;
            if (D.32220 == 40) goto <D.38168>; else goto <D.38173>;
            <D.38173>:
            D.31664 = ip + 5;
            D.32220 = *D.31664;
            if (D.32220 == 111) goto <D.38168>; else goto <D.38167>;
            <D.38168>:
            D.34754 = ip + 6;
            D.34790 = MEM[(const guint32 *)D.34754];
            D.34791 = D.34790 << 24;
            D.34754 = ip + 6;
            D.34790 = MEM[(const guint32 *)D.34754];
            D.34792 = D.34790 >> 8;
            D.34793 = D.34792 & 65280;
            D.34794 = D.34791 | D.34793;
            D.34754 = ip + 6;
            D.34790 = MEM[(const guint32 *)D.34754];
            D.34795 = D.34790 << 8;
            D.34796 = D.34795 & 16711680;
            D.34797 = D.34794 | D.34796;
            D.34754 = ip + 6;
            D.34790 = MEM[(const guint32 *)D.34754];
            D.34798 = D.34790 >> 24;
            D.34799 = D.34797 | D.34798;
            cmethod = mini_get_method (cfg, method, D.34799, 0B, generic_context);
            if (cmethod != 0B) goto <D.38174>; else goto <D.38167>;
            <D.38174>:
            D.32125 = cmethod->klass;
            D.38175 = mono_defaults.systemtype_class;
            if (D.32125 == D.38175) goto <D.38176>; else goto <D.38167>;
            <D.38176>:
            D.32594 = cmethod->name;
            D.38177 = strcmp (D.32594, "GetTypeFromHandle");
            if (D.38177 == 0) goto <D.38178>; else goto <D.38167>;
            <D.38178>:
            {
              struct MonoClass * tclass;

              tclass = mono_class_from_mono_type (handle);
              mono_class_init (tclass);
              if (context_used != 0) goto <D.38179>; else goto <D.38180>;
              <D.38179>:
              ins = emit_get_rgctx_klass (cfg, context_used, tclass, 4);
              goto <D.38181>;
              <D.38180>:
              D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.30635 = D.30634 & 33554432;
              if (D.30635 != 0) goto <D.38182>; else goto <D.38183>;
              <D.38182>:
              D.30183 = BIT_FIELD_REF <*method, 64, 256>;
              D.30184 = D.30183 & 4467570830351532032;
              if (D.30184 != 0) goto <D.38184>; else goto <D.38185>;
              <D.38184>:
              D.38188 = tclass->image;
              D.38189 = tclass->type_token;
              D.38190 = mono_class_get (D.38188, D.38189);
              if (D.38190 == tclass) goto <D.38191>; else goto <D.38186>;
              <D.38191>:
              if (generic_context == 0B) goto <D.38192>; else goto <D.38186>;
              <D.38192>:
              D.30241 = cfg->mempool;
              ins = mono_mempool_alloc (D.30241, 80);
              ins->data.op[1].const_val = 0;
              D.30457 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.30457;
              ins->prev = 0B;
              D.30458 = ins->prev;
              ins->next = D.30458;
              ins->opcode = 732;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.30459 = ins->sreg3;
              ins->sreg2 = D.30459;
              D.30460 = ins->sreg2;
              ins->sreg1 = D.30460;
              D.30461 = cfg->ip;
              ins->cil_code = D.30461;
              D.30241 = cfg->mempool;
              D.38188 = tclass->image;
              D.38189 = tclass->type_token;
              D.38193 = mono_jump_info_token_new2 (D.30241, D.38188, D.38189, generic_context);
              ins->data.op[0].p = D.38193;
              ins->data.op[1].p = 19B;
              ins->type = 6;
              D.38194 = mono_defaults.monotype_class;
              ins->klass = D.38194;
              D.38195 = alloc_dreg (cfg, 6);
              D.38196 = (int) D.38195;
              ins->dreg = D.38196;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.38197>; else goto <D.38198>;
              <D.38197>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = ins;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              ins->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              goto <D.38199>;
              <D.38198>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.38199>:
              goto <D.38187>;
              <D.38186>:
              D.30322 = cfg->verbose_level;
              if (D.30322 > 1) goto <D.38200>; else goto <D.38201>;
              <D.38200>:
              printf ("AOT disabled: %s:%d\n", "method-to-ir.c", 10842);
              <D.38201>:
              cfg->disable_aot = 1;
              D.30241 = cfg->mempool;
              ins = mono_mempool_alloc (D.30241, 80);
              ins->data.op[1].const_val = 0;
              D.30457 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.30457;
              ins->prev = 0B;
              D.30458 = ins->prev;
              ins->next = D.30458;
              ins->opcode = 363;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.30459 = ins->sreg3;
              ins->sreg2 = D.30459;
              D.30460 = ins->sreg2;
              ins->sreg1 = D.30460;
              D.30461 = cfg->ip;
              ins->cil_code = D.30461;
              ins->data.op[0].p = 0B;
              ins->type = 3;
              D.38202 = alloc_dreg (cfg, 3);
              D.38203 = (int) D.38202;
              ins->dreg = D.38203;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.38204>; else goto <D.38205>;
              <D.38204>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = ins;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              ins->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              goto <D.38206>;
              <D.38205>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.38206>:
              <D.38187>:
              goto <D.38207>;
              <D.38185>:
              D.30241 = cfg->mempool;
              ins = mono_mempool_alloc (D.30241, 80);
              ins->data.op[1].const_val = 0;
              D.30457 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.30457;
              ins->prev = 0B;
              D.30458 = ins->prev;
              ins->next = D.30458;
              ins->opcode = 732;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.30459 = ins->sreg3;
              ins->sreg2 = D.30459;
              D.30460 = ins->sreg2;
              ins->sreg1 = D.30460;
              D.30461 = cfg->ip;
              ins->cil_code = D.30461;
              D.30241 = cfg->mempool;
              n.148 = (unsigned int) n;
              D.38208 = mono_jump_info_token_new2 (D.30241, image, n.148, generic_context);
              ins->data.op[0].p = D.38208;
              ins->data.op[1].p = 19B;
              ins->type = 6;
              D.38194 = mono_defaults.monotype_class;
              ins->klass = D.38194;
              D.38209 = alloc_dreg (cfg, 6);
              D.38210 = (int) D.38209;
              ins->dreg = D.38210;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.38211>; else goto <D.38212>;
              <D.38211>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = ins;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              ins->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              goto <D.38213>;
              <D.38212>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.38213>:
              <D.38207>:
              goto <D.38214>;
              <D.38183>:
              D.30241 = cfg->mempool;
              ins = mono_mempool_alloc (D.30241, 80);
              ins->data.op[1].const_val = 0;
              D.30457 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.30457;
              ins->prev = 0B;
              D.30458 = ins->prev;
              ins->next = D.30458;
              ins->opcode = 363;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.30459 = ins->sreg3;
              ins->sreg2 = D.30459;
              D.30460 = ins->sreg2;
              ins->sreg1 = D.30460;
              D.30461 = cfg->ip;
              ins->cil_code = D.30461;
              D.30267 = cfg->domain;
              D.38215 = mono_type_get_object (D.30267, handle);
              ins->data.op[0].p = D.38215;
              ins->type = 3;
              D.38216 = alloc_dreg (cfg, 3);
              D.38217 = (int) D.38216;
              ins->dreg = D.38217;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.38218>; else goto <D.38219>;
              <D.38218>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = ins;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              ins->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              goto <D.38220>;
              <D.38219>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.38220>:
              <D.38214>:
              <D.38181>:
              ins->type = 6;
              D.32125 = cmethod->klass;
              ins->klass = D.32125;
              ip = ip + 5;
            }
            goto <D.38169>;
            <D.38167>:
            {
              struct MonoInst * addr;
              struct MonoInst * vtvar;

              handle_class.255 = handle_class;
              D.38048 = &handle_class.255->byval_arg;
              vtvar = mono_compile_create_var (cfg, D.38048, 329);
              if (context_used != 0) goto <D.38221>; else goto <D.38222>;
              <D.38221>:
              D.38009 = mono_defaults.typehandle_class;
              handle_class.255 = handle_class;
              if (D.38009 == handle_class.255) goto <D.38223>; else goto <D.38224>;
              <D.38223>:
              D.38225 = mono_class_from_mono_type (handle);
              ins = emit_get_rgctx_klass (cfg, context_used, D.38225, 3);
              goto <D.38226>;
              <D.38224>:
              D.38039 = mono_defaults.methodhandle_class;
              handle_class.255 = handle_class;
              if (D.38039 == handle_class.255) goto <D.38227>; else goto <D.38228>;
              <D.38227>:
              ins = emit_get_rgctx_method (cfg, context_used, handle, 5);
              goto <D.38229>;
              <D.38228>:
              D.38034 = mono_defaults.fieldhandle_class;
              handle_class.255 = handle_class;
              if (D.38034 == handle_class.255) goto <D.38230>; else goto <D.38231>;
              <D.38230>:
              ins = emit_get_rgctx_field (cfg, context_used, handle, 7);
              goto <D.38232>;
              <D.38231>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 10871);
              <D.38232>:
              <D.38229>:
              <D.38226>:
              goto <D.38233>;
              <D.38222>:
              D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.30635 = D.30634 & 33554432;
              if (D.30635 != 0) goto <D.38234>; else goto <D.38235>;
              <D.38234>:
              D.30241 = cfg->mempool;
              ins = mono_mempool_alloc (D.30241, 80);
              ins->data.op[1].const_val = 0;
              D.30457 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.30457;
              ins->prev = 0B;
              D.30458 = ins->prev;
              ins->next = D.30458;
              ins->opcode = 732;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.30459 = ins->sreg3;
              ins->sreg2 = D.30459;
              D.30460 = ins->sreg2;
              ins->sreg1 = D.30460;
              D.30461 = cfg->ip;
              ins->cil_code = D.30461;
              D.30241 = cfg->mempool;
              n.148 = (unsigned int) n;
              D.38236 = mono_jump_info_token_new2 (D.30241, image, n.148, generic_context);
              ins->data.op[0].p = D.38236;
              ins->data.op[1].p = 18B;
              ins->type = 3;
              ins->klass = 0B;
              D.38237 = alloc_dreg (cfg, 3);
              D.38238 = (int) D.38237;
              ins->dreg = D.38238;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.38239>; else goto <D.38240>;
              <D.38239>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = ins;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              ins->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              goto <D.38241>;
              <D.38240>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.38241>:
              goto <D.38242>;
              <D.38235>:
              D.30241 = cfg->mempool;
              ins = mono_mempool_alloc (D.30241, 80);
              ins->data.op[1].const_val = 0;
              D.30457 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.30457;
              ins->prev = 0B;
              D.30458 = ins->prev;
              ins->next = D.30458;
              ins->opcode = 363;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.30459 = ins->sreg3;
              ins->sreg2 = D.30459;
              D.30460 = ins->sreg2;
              ins->sreg1 = D.30460;
              D.30461 = cfg->ip;
              ins->cil_code = D.30461;
              ins->data.op[0].p = handle;
              ins->type = 3;
              D.38243 = alloc_dreg (cfg, 3);
              D.38244 = (int) D.38243;
              ins->dreg = D.38244;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.38245>; else goto <D.38246>;
              <D.38245>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = ins;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              ins->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              goto <D.38247>;
              <D.38246>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.38247>:
              <D.38242>:
              <D.38233>:
              D.30241 = cfg->mempool;
              addr = mono_mempool_alloc (D.30241, 80);
              addr->data.op[1].const_val = 0;
              D.38248 = addr->data.op[1].const_val;
              addr->data.op[0].const_val = D.38248;
              addr->prev = 0B;
              D.38249 = addr->prev;
              addr->next = D.38249;
              addr->opcode = 314;
              addr->flags = 0;
              addr->type = 0;
              addr->dreg = -1;
              addr->sreg3 = -1;
              D.38250 = addr->sreg3;
              addr->sreg2 = D.38250;
              D.38251 = addr->sreg2;
              addr->sreg1 = D.38251;
              D.30461 = cfg->ip;
              addr->cil_code = D.30461;
              D.30978 = cfg->varinfo;
              D.38252 = vtvar->data.op[0].const_val;
              D.38253 = (long unsigned int) D.38252;
              D.38254 = D.38253 * 8;
              D.38255 = D.30978 + D.38254;
              D.38256 = *D.38255;
              addr->data.op[0].p = D.38256;
              D.30978 = cfg->varinfo;
              D.38252 = vtvar->data.op[0].const_val;
              D.38253 = (long unsigned int) D.38252;
              D.38254 = D.38253 * 8;
              D.38255 = D.30978 + D.38254;
              D.38256 = *D.38255;
              D.30978 = cfg->varinfo;
              D.38252 = vtvar->data.op[0].const_val;
              D.38253 = (long unsigned int) D.38252;
              D.38254 = D.38253 * 8;
              D.38255 = D.30978 + D.38254;
              D.38256 = *D.38255;
              D.38257 = D.38256->flags;
              D.38258 = D.38257 | 16;
              D.38256->flags = D.38258;
              addr->type = 5;
              D.30978 = cfg->varinfo;
              D.38252 = vtvar->data.op[0].const_val;
              D.38253 = (long unsigned int) D.38252;
              D.38254 = D.38253 * 8;
              D.38255 = D.30978 + D.38254;
              D.38256 = *D.38255;
              D.38259 = D.38256->klass;
              addr->klass = D.38259;
              D.38260 = alloc_dreg (cfg, 5);
              D.38261 = (int) D.38260;
              addr->dreg = D.38261;
              cfg->has_indirection = 1;
              D.30389 = cfg->gsharedvt;
              D.31326 = D.30389 != 0;
              D.31327 = (long int) D.31326;
              D.31328 = __builtin_expect (D.31327, 0);
              if (D.31328 != 0) goto <D.38262>; else goto <D.38263>;
              <D.38262>:
              D.30978 = cfg->varinfo;
              D.38252 = vtvar->data.op[0].const_val;
              D.38253 = (long unsigned int) D.38252;
              D.38254 = D.38253 * 8;
              D.38255 = D.30978 + D.38254;
              D.38256 = *D.38255;
              D.38264 = D.38256->data.op[1].vtype;
              D.38265 = mini_is_gsharedvt_variable_type (cfg, D.38264);
              if (D.38265 != 0) goto <D.38266>; else goto <D.38267>;
              <D.38266>:
              handle_gsharedvt_ldaddr (cfg);
              <D.38267>:
              <D.38263>:
              if (0 != 0) goto <D.38268>; else goto <D.38269>;
              <D.38268>:
              {
                struct MonoInst * var1;
                struct MonoInst * var2;

                D.30978 = cfg->varinfo;
                D.38252 = vtvar->data.op[0].const_val;
                D.38253 = (long unsigned int) D.38252;
                D.38254 = D.38253 * 8;
                D.38255 = D.30978 + D.38254;
                D.38256 = *D.38255;
                D.38271 = D.38256->dreg;
                D.38272 = D.38271 + 1;
                D.38273 = (unsigned int) D.38272;
                D.31341 = cfg->vreg_to_inst_len;
                if (D.38273 < D.31341) goto <D.38274>; else goto <D.38275>;
                <D.38274>:
                D.31344 = cfg->vreg_to_inst;
                D.30978 = cfg->varinfo;
                D.38252 = vtvar->data.op[0].const_val;
                D.38253 = (long unsigned int) D.38252;
                D.38254 = D.38253 * 8;
                D.38255 = D.30978 + D.38254;
                D.38256 = *D.38255;
                D.38271 = D.38256->dreg;
                D.38276 = (sizetype) D.38271;
                D.38277 = D.38276 + 1;
                D.38278 = D.38277 * 8;
                D.38279 = D.31344 + D.38278;
                iftmp.259 = *D.38279;
                goto <D.38280>;
                <D.38275>:
                iftmp.259 = 0B;
                <D.38280>:
                var1 = iftmp.259;
                D.30978 = cfg->varinfo;
                D.38252 = vtvar->data.op[0].const_val;
                D.38253 = (long unsigned int) D.38252;
                D.38254 = D.38253 * 8;
                D.38255 = D.30978 + D.38254;
                D.38256 = *D.38255;
                D.38271 = D.38256->dreg;
                D.38282 = D.38271 + 2;
                D.38283 = (unsigned int) D.38282;
                D.31341 = cfg->vreg_to_inst_len;
                if (D.38283 < D.31341) goto <D.38284>; else goto <D.38285>;
                <D.38284>:
                D.31344 = cfg->vreg_to_inst;
                D.30978 = cfg->varinfo;
                D.38252 = vtvar->data.op[0].const_val;
                D.38253 = (long unsigned int) D.38252;
                D.38254 = D.38253 * 8;
                D.38255 = D.30978 + D.38254;
                D.38256 = *D.38255;
                D.38271 = D.38256->dreg;
                D.38276 = (sizetype) D.38271;
                D.38286 = D.38276 + 2;
                D.38287 = D.38286 * 8;
                D.38288 = D.31344 + D.38287;
                iftmp.260 = *D.38288;
                goto <D.38289>;
                <D.38285>:
                iftmp.260 = 0B;
                <D.38289>:
                var2 = iftmp.260;
                D.38290 = var1 == 0B;
                D.38291 = (long int) D.38290;
                D.38292 = __builtin_expect (D.38291, 0);
                if (D.38292 != 0) goto <D.38293>; else goto <D.38294>;
                <D.38293>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10878, "var1");
                <D.38294>:
                D.38295 = var2 == 0B;
                D.38296 = (long int) D.38295;
                D.38297 = __builtin_expect (D.38296, 0);
                if (D.38297 != 0) goto <D.38298>; else goto <D.38299>;
                <D.38298>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10878, "var2");
                <D.38299>:
                D.38300 = var1->flags;
                D.38301 = D.38300 | 16;
                var1->flags = D.38301;
                D.38302 = var2->flags;
                D.38303 = D.38302 | 16;
                var2->flags = D.38303;
              }
              <D.38269>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.38304>; else goto <D.38305>;
              <D.38304>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = addr;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              addr->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = addr;
              goto <D.38306>;
              <D.38305>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = addr;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.38306>:
              {
                struct MonoInst * inst;

                D.30241 = cfg->mempool;
                inst = mono_mempool_alloc (D.30241, 80);
                inst->data.op[1].const_val = 0;
                D.38307 = inst->data.op[1].const_val;
                inst->data.op[0].const_val = D.38307;
                inst->prev = 0B;
                D.38308 = inst->prev;
                inst->next = D.38308;
                inst->opcode = 374;
                inst->flags = 0;
                inst->type = 0;
                inst->dreg = -1;
                inst->sreg3 = -1;
                D.38309 = inst->sreg3;
                inst->sreg2 = D.38309;
                D.38310 = inst->sreg2;
                inst->sreg1 = D.38310;
                D.30461 = cfg->ip;
                inst->cil_code = D.30461;
                D.30654 = ins->dreg;
                inst->sreg1 = D.30654;
                D.38311 = addr->dreg;
                inst->dreg = D.38311;
                inst->data.op[0].const_val = 0;
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                if (D.30490 != 0B) goto <D.38312>; else goto <D.38313>;
                <D.38312>:
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                D.30490->next = inst;
                bblock.106 = cfg->cbb;
                D.30490 = bblock.106->last_ins;
                inst->prev = D.30490;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                goto <D.38314>;
                <D.38313>:
                bblock.106 = cfg->cbb;
                bblock.106 = cfg->cbb;
                bblock.106->last_ins = inst;
                D.30490 = bblock.106->last_ins;
                bblock.106->code = D.30490;
                <D.38314>:
              }
              D.30241 = cfg->mempool;
              ins = mono_mempool_alloc (D.30241, 80);
              ins->data.op[1].const_val = 0;
              D.30457 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.30457;
              ins->prev = 0B;
              D.30458 = ins->prev;
              ins->next = D.30458;
              ins->opcode = 424;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.30459 = ins->sreg3;
              ins->sreg2 = D.30459;
              D.30460 = ins->sreg2;
              ins->sreg1 = D.30460;
              D.30461 = cfg->ip;
              ins->cil_code = D.30461;
              D.30978 = cfg->varinfo;
              D.38252 = vtvar->data.op[0].const_val;
              D.38253 = (long unsigned int) D.38252;
              D.38254 = D.38253 * 8;
              D.38255 = D.30978 + D.38254;
              D.38256 = *D.38255;
              D.38264 = D.38256->data.op[1].vtype;
              D.38315 = mono_type_to_regmove (cfg, D.38264);
              D.38316 = (short unsigned int) D.38315;
              ins->opcode = D.38316;
              D.30978 = cfg->varinfo;
              D.38252 = vtvar->data.op[0].const_val;
              D.38253 = (long unsigned int) D.38252;
              D.38254 = D.38253 * 8;
              D.38255 = D.30978 + D.38254;
              D.38256 = *D.38255;
              D.38264 = D.38256->data.op[1].vtype;
              type_to_eval_stack_type (cfg, D.38264, ins);
              D.30978 = cfg->varinfo;
              D.38252 = vtvar->data.op[0].const_val;
              D.38253 = (long unsigned int) D.38252;
              D.38254 = D.38253 * 8;
              D.38255 = D.30978 + D.38254;
              D.38256 = *D.38255;
              D.38259 = D.38256->klass;
              ins->klass = D.38259;
              D.30978 = cfg->varinfo;
              D.38252 = vtvar->data.op[0].const_val;
              D.38253 = (long unsigned int) D.38252;
              D.38254 = D.38253 * 8;
              D.38255 = D.30978 + D.38254;
              D.38256 = *D.38255;
              D.38271 = D.38256->dreg;
              ins->sreg1 = D.38271;
              D.30988 = ins->type;
              D.30989 = (<unnamed type>) D.30988;
              D.38317 = alloc_dreg (cfg, D.30989);
              D.38318 = (int) D.38317;
              ins->dreg = D.38318;
              D.30992 = ins->opcode;
              if (D.30992 == 427) goto <D.38319>; else goto <D.38320>;
              <D.38319>:
              D.30978 = cfg->varinfo;
              D.38252 = vtvar->data.op[0].const_val;
              D.38253 = (long unsigned int) D.38252;
              D.38254 = D.38253 * 8;
              D.38255 = D.30978 + D.38254;
              D.38256 = *D.38255;
              D.38264 = D.38256->data.op[1].vtype;
              D.38321 = mono_class_from_mono_type (D.38264);
              ins->klass = D.38321;
              <D.38320>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.38322>; else goto <D.38323>;
              <D.38322>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = ins;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              ins->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              goto <D.38324>;
              <D.38323>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.38324>:
            }
            <D.38169>:
            <D.38044>:
            sp.261 = sp;
            sp = sp.261 + 8;
            *sp.261 = ins;
            ip = ip + 5;
            goto <D.27394>;
          }
        finally
          {
            handle_class = {CLOBBER};
          }
      }
      <D.27994>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.38326>; else goto <D.38327>;
      <D.38326>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.38328>; else goto <D.38329>;
      <D.38328>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.38330>; else goto <D.38331>;
      <D.38330>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.38331>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.38329>:
      D.38332 = mini_get_debug_options ();
      D.38333 = D.38332->break_on_unverified;
      if (D.38333 != 0) goto <D.38334>; else goto unverified;
      <D.38334>:
      raise (5);
      <D.38327>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 371;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      sp = sp + 18446744073709551608;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      ip = ip + 1;
      bblock.64 = bblock;
      bblock.64->out_of_line = 1;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      if (D.30577 != 0B) goto <D.38335>; else goto <D.38336>;
      <D.38335>:
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      D.30577->next = ins;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      ins->prev = D.30577;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      goto <D.38337>;
      <D.38336>:
      bblock.64 = bblock;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      D.30577 = bblock.64->last_ins;
      bblock.64->code = D.30577;
      <D.38337>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 798;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      if (D.30577 != 0B) goto <D.38338>; else goto <D.38339>;
      <D.38338>:
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      D.30577->next = ins;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      ins->prev = D.30577;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      goto <D.38340>;
      <D.38339>:
      bblock.64 = bblock;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      D.30577 = bblock.64->last_ins;
      bblock.64->code = D.30577;
      <D.38340>:
      sp = stack_start;
      bblock.64 = bblock;
      link_bblock (cfg, bblock.64, end_bblock);
      start_new_bblock = 1;
      goto <D.27394>;
      <D.27995>:
      if (sp != stack_start) goto <D.38341>; else goto <D.38342>;
      <D.38341>:
      emit_seq_point (cfg, method, ip, 0, 0);
      <D.38342>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 738;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      if (D.30577 != 0B) goto <D.38343>; else goto <D.38344>;
      <D.38343>:
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      D.30577->next = ins;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      ins->prev = D.30577;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      goto <D.38345>;
      <D.38344>:
      bblock.64 = bblock;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      D.30577 = bblock.64->last_ins;
      bblock.64->code = D.30577;
      <D.38345>:
      ip = ip + 1;
      start_new_bblock = 1;
      goto <D.27997>;
      <D.27996>:
      sp = sp + 18446744073709551608;
      <D.27997>:
      if (sp != stack_start) goto <D.27996>; else goto <D.27998>;
      <D.27998>:
      goto <D.27394>;
      <D.27999>:
      <D.28000>:
      {
        struct GList * handlers;

        D.31121 = *ip;
        if (D.31121 == 221) goto <D.38346>; else goto <D.38347>;
        <D.38346>:
        D.31664 = ip + 5;
        if (D.31664 > end) goto <D.38348>; else goto <D.38349>;
        <D.38348>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.38350>; else goto <D.38351>;
        <D.38350>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.38352>; else goto <D.38353>;
        <D.38352>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.38353>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38351>:
        D.38354 = mini_get_debug_options ();
        D.38355 = D.38354->break_on_unverified;
        if (D.38355 != 0) goto <D.38356>; else goto unverified;
        <D.38356>:
        raise (5);
        <D.38349>:
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31684 = D.31683 << 24;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31685 = D.31683 >> 8;
        D.31686 = D.31685 & 65280;
        D.31687 = D.31684 | D.31686;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31688 = D.31683 << 8;
        D.31689 = D.31688 & 16711680;
        D.31690 = D.31687 | D.31689;
        D.31270 = ip + 1;
        D.31683 = MEM[(const guint32 *)D.31270];
        D.31691 = D.31683 >> 24;
        D.31692 = D.31690 | D.31691;
        D.31693 = (int) D.31692;
        D.38357 = (sizetype) D.31693;
        D.38358 = D.38357 + 5;
        target = ip + D.38358;
        goto <D.38359>;
        <D.38347>:
        D.31251 = ip + 2;
        if (D.31251 > end) goto <D.38360>; else goto <D.38361>;
        <D.38360>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.38362>; else goto <D.38363>;
        <D.38362>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.38364>; else goto <D.38365>;
        <D.38364>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.38365>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38363>:
        D.38366 = mini_get_debug_options ();
        D.38367 = D.38366->break_on_unverified;
        if (D.38367 != 0) goto <D.38368>; else goto unverified;
        <D.38368>:
        raise (5);
        <D.38361>:
        D.31270 = ip + 1;
        D.31271 = *D.31270;
        D.38369 = (signed char) D.31271;
        D.38370 = (sizetype) D.38369;
        D.38371 = D.38370 + 2;
        target = ip + D.38371;
        <D.38359>:
        goto <D.28003>;
        <D.28002>:
        sp = sp + 18446744073709551608;
        <D.28003>:
        if (sp != stack_start) goto <D.28002>; else goto <D.28004>;
        <D.28004>:
        i = 0;
        goto <D.28013>;
        <D.28012>:
        {
          struct MonoExceptionClause * clause;

          D.30369 = header->clauses;
          D.30370 = (long unsigned int) i;
          D.30371 = D.30370 * 32;
          clause = D.30369 + D.30371;
          D.38372 = clause->handler_offset;
          D.38373 = (long int) D.38372;
          ip.69 = (long int) ip;
          D.30388 = header->code;
          D.30933 = (long int) D.30388;
          D.30934 = ip.69 - D.30933;
          if (D.38373 <= D.30934) goto <D.38374>; else goto <D.38375>;
          <D.38374>:
          ip.69 = (long int) ip;
          D.30388 = header->code;
          D.30933 = (long int) D.30388;
          D.30934 = ip.69 - D.30933;
          D.38372 = clause->handler_offset;
          D.38376 = clause->handler_len;
          D.38377 = D.38372 + D.38376;
          D.38378 = (long int) D.38377;
          if (D.30934 < D.38378) goto <D.38379>; else goto <D.38380>;
          <D.38379>:
          D.38381 = clause->flags;
          if (D.38381 == 0) goto <D.38382>; else goto <D.38383>;
          <D.38382>:
          ip.69 = (long int) ip;
          D.30388 = header->code;
          D.30933 = (long int) D.30388;
          D.30934 = ip.69 - D.30933;
          D.31121 = *ip;
          if (D.31121 == 221) goto <D.38385>; else goto <D.38386>;
          <D.38385>:
          iftmp.262 = 5;
          goto <D.38387>;
          <D.38386>:
          iftmp.262 = 2;
          <D.38387>:
          D.38388 = D.30934 + iftmp.262;
          D.38372 = clause->handler_offset;
          D.38376 = clause->handler_len;
          D.38377 = D.38372 + D.38376;
          D.38378 = (long int) D.38377;
          if (D.38388 <= D.38378) goto <D.38389>; else goto <D.38390>;
          <D.38389>:
          D.30183 = BIT_FIELD_REF <*method, 64, 256>;
          D.30184 = D.30183 & 4467570830351532032;
          if (D.30184 != 576460752303423488) goto <D.38391>; else goto <D.38392>;
          <D.38391>:
          {
            struct MonoInst * exc_ins;
            struct MonoBasicBlock * dont_throw;

            exc_ins = mono_emit_jit_icall (cfg, mono_thread_get_undeniable_exception, 0B);
            D.30241 = cfg->mempool;
            dont_throw = mono_mempool_alloc0 (D.30241, 296);
            D.30349 = cfg->num_bblocks;
            D.38393 = D.30349;
            D.38394 = D.38393 + 1;
            cfg->num_bblocks = D.38394;
            D.38395 = (int) D.38393;
            dont_throw->block_num = D.38395;
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.38396 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.38396;
              inst->prev = 0B;
              D.38397 = inst->prev;
              inst->next = D.38397;
              inst->opcode = 323;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.38398 = inst->sreg3;
              inst->sreg2 = D.38398;
              D.38399 = inst->sreg2;
              inst->sreg1 = D.38399;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = -1;
              D.38400 = exc_ins->dreg;
              inst->sreg1 = D.38400;
              inst->data.op[1].const_val = 0;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.38401>; else goto <D.38402>;
              <D.38401>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.38403>;
              <D.38402>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.38403>:
            }
            {
              struct MonoInst * ins;
              struct MonoBasicBlock * falsebb;

              D.30241 = cfg->mempool;
              ins = mono_mempool_alloc (D.30241, 80);
              ins->data.op[1].const_val = 0;
              D.38404 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.38404;
              ins->prev = 0B;
              D.38405 = ins->prev;
              ins->next = D.38405;
              ins->opcode = 551;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.38406 = ins->sreg3;
              ins->sreg2 = D.38406;
              D.38407 = ins->sreg2;
              ins->sreg1 = D.38407;
              D.30461 = cfg->ip;
              ins->cil_code = D.30461;
              if (0 != 0) goto <D.38408>; else goto <D.38409>;
              <D.38408>:
              D.30241 = cfg->mempool;
              falsebb = mono_mempool_alloc0 (D.30241, 296);
              D.30349 = cfg->num_bblocks;
              D.38410 = D.30349;
              D.38411 = D.38410 + 1;
              cfg->num_bblocks = D.38411;
              D.38412 = (int) D.38410;
              falsebb->block_num = D.38412;
              ins->data.op[0].target_block = dont_throw;
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, dont_throw);
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.38413>; else goto <D.38414>;
              <D.38413>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = ins;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              ins->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              goto <D.38415>;
              <D.38414>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.38415>:
              D.38416 = falsebb->cil_code;
              if (D.38416 != 0B) goto <D.38417>; else goto <D.38418>;
              <D.38417>:
              D.30372 = cfg->cil_offset_to_bb;
              D.38416 = falsebb->cil_code;
              D.38419 = (long int) D.38416;
              D.30377 = cfg->cil_start;
              D.30378 = (long int) D.30377;
              D.38420 = D.38419 - D.30378;
              D.38421 = (long unsigned int) D.38420;
              D.38422 = D.38421 * 8;
              D.38423 = D.30372 + D.38422;
              *D.38423 = falsebb;
              <D.38418>:
              D.30408 = cfg->real_offset;
              falsebb->real_offset = D.30408;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.38427>; else goto <D.38424>;
              <D.38427>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34178 = D.34177 + 64985;
              if (D.34178 <= 9) goto <D.38425>; else goto <D.38428>;
              <D.38428>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34180 = D.34177 + 64878;
              if (D.34180 <= 9) goto <D.38425>; else goto <D.38429>;
              <D.38429>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34182 = D.34177 + 64888;
              if (D.34182 <= 9) goto <D.38425>; else goto <D.38424>;
              <D.38425>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34183 = D.30490->data.op[1].many_blocks;
              D.34184 = D.34183 + 8;
              D.34185 = *D.34184;
              if (D.34185 == 0B) goto <D.38430>; else goto <D.38424>;
              <D.38430>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34183 = D.30490->data.op[1].many_blocks;
              D.34184 = D.34183 + 8;
              *D.34184 = falsebb;
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, falsebb);
              goto <D.38426>;
              <D.38424>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 == 0B) goto <D.38431>; else goto <D.38433>;
              <D.38433>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              if (D.34177 != 442) goto <D.38434>; else goto <D.38432>;
              <D.38434>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              if (D.34177 != 759) goto <D.38435>; else goto <D.38432>;
              <D.38435>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34178 = D.34177 + 64985;
              if (D.34178 > 9) goto <D.38436>; else goto <D.38432>;
              <D.38436>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34180 = D.34177 + 64878;
              if (D.34180 > 9) goto <D.38437>; else goto <D.38432>;
              <D.38437>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34182 = D.34177 + 64888;
              if (D.34182 > 9) goto <D.38431>; else goto <D.38432>;
              <D.38431>:
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, falsebb);
              <D.38432>:
              <D.38426>:
              bblock.106 = cfg->cbb;
              bblock.106->next_bb = falsebb;
              cfg->cbb = falsebb;
              goto <D.38438>;
              <D.38409>:
              D.30241 = cfg->mempool;
              D.38439 = mono_mempool_alloc (D.30241, 16);
              ins->data.op[1].many_blocks = D.38439;
              D.38440 = ins->data.op[1].many_blocks;
              *D.38440 = dont_throw;
              D.38440 = ins->data.op[1].many_blocks;
              D.38441 = D.38440 + 8;
              *D.38441 = 0B;
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, dont_throw);
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.38442>; else goto <D.38443>;
              <D.38442>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = ins;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              ins->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              goto <D.38444>;
              <D.38443>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.38444>:
              D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.34201 = D.30634 & 268435456;
              if (D.34201 == 0) goto <D.38445>; else goto <D.38446>;
              <D.38445>:
              D.30241 = cfg->mempool;
              falsebb = mono_mempool_alloc0 (D.30241, 296);
              D.30349 = cfg->num_bblocks;
              D.38447 = D.30349;
              D.38448 = D.38447 + 1;
              cfg->num_bblocks = D.38448;
              D.38449 = (int) D.38447;
              falsebb->block_num = D.38449;
              D.38440 = ins->data.op[1].many_blocks;
              D.38441 = D.38440 + 8;
              *D.38441 = falsebb;
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, falsebb);
              D.38416 = falsebb->cil_code;
              if (D.38416 != 0B) goto <D.38450>; else goto <D.38451>;
              <D.38450>:
              D.30372 = cfg->cil_offset_to_bb;
              D.38416 = falsebb->cil_code;
              D.38419 = (long int) D.38416;
              D.30377 = cfg->cil_start;
              D.30378 = (long int) D.30377;
              D.38420 = D.38419 - D.30378;
              D.38421 = (long unsigned int) D.38420;
              D.38422 = D.38421 * 8;
              D.38423 = D.30372 + D.38422;
              *D.38423 = falsebb;
              <D.38451>:
              D.30408 = cfg->real_offset;
              falsebb->real_offset = D.30408;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.38455>; else goto <D.38452>;
              <D.38455>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34178 = D.34177 + 64985;
              if (D.34178 <= 9) goto <D.38453>; else goto <D.38456>;
              <D.38456>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34180 = D.34177 + 64878;
              if (D.34180 <= 9) goto <D.38453>; else goto <D.38457>;
              <D.38457>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34182 = D.34177 + 64888;
              if (D.34182 <= 9) goto <D.38453>; else goto <D.38452>;
              <D.38453>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34183 = D.30490->data.op[1].many_blocks;
              D.34184 = D.34183 + 8;
              D.34185 = *D.34184;
              if (D.34185 == 0B) goto <D.38458>; else goto <D.38452>;
              <D.38458>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34183 = D.30490->data.op[1].many_blocks;
              D.34184 = D.34183 + 8;
              *D.34184 = falsebb;
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, falsebb);
              goto <D.38454>;
              <D.38452>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 == 0B) goto <D.38459>; else goto <D.38461>;
              <D.38461>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              if (D.34177 != 442) goto <D.38462>; else goto <D.38460>;
              <D.38462>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              if (D.34177 != 759) goto <D.38463>; else goto <D.38460>;
              <D.38463>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34178 = D.34177 + 64985;
              if (D.34178 > 9) goto <D.38464>; else goto <D.38460>;
              <D.38464>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34180 = D.34177 + 64878;
              if (D.34180 > 9) goto <D.38465>; else goto <D.38460>;
              <D.38465>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34182 = D.34177 + 64888;
              if (D.34182 > 9) goto <D.38459>; else goto <D.38460>;
              <D.38459>:
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, falsebb);
              <D.38460>:
              <D.38454>:
              bblock.106 = cfg->cbb;
              bblock.106->next_bb = falsebb;
              cfg->cbb = falsebb;
              goto <D.38466>;
              <D.38446>:
              bblock.106 = cfg->cbb;
              bblock.106->extended = 1;
              <D.38466>:
              <D.38438>:
            }
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.38467 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.38467;
              inst->prev = 0B;
              D.38468 = inst->prev;
              inst->next = D.38468;
              inst->opcode = 371;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.38469 = inst->sreg3;
              inst->sreg2 = D.38469;
              D.38470 = inst->sreg2;
              inst->sreg1 = D.38470;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = -1;
              D.38400 = exc_ins->dreg;
              inst->sreg1 = D.38400;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.38471>; else goto <D.38472>;
              <D.38471>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.38473>;
              <D.38472>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.38473>:
            }
            D.38474 = dont_throw->cil_code;
            if (D.38474 != 0B) goto <D.38475>; else goto <D.38476>;
            <D.38475>:
            D.30372 = cfg->cil_offset_to_bb;
            D.38474 = dont_throw->cil_code;
            D.38477 = (long int) D.38474;
            D.30377 = cfg->cil_start;
            D.30378 = (long int) D.30377;
            D.38478 = D.38477 - D.30378;
            D.38479 = (long unsigned int) D.38478;
            D.38480 = D.38479 * 8;
            D.38481 = D.30372 + D.38480;
            *D.38481 = dont_throw;
            <D.38476>:
            D.30408 = cfg->real_offset;
            dont_throw->real_offset = D.30408;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.38485>; else goto <D.38482>;
            <D.38485>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34177 = D.30490->opcode;
            D.34178 = D.34177 + 64985;
            if (D.34178 <= 9) goto <D.38483>; else goto <D.38486>;
            <D.38486>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34177 = D.30490->opcode;
            D.34180 = D.34177 + 64878;
            if (D.34180 <= 9) goto <D.38483>; else goto <D.38487>;
            <D.38487>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34177 = D.30490->opcode;
            D.34182 = D.34177 + 64888;
            if (D.34182 <= 9) goto <D.38483>; else goto <D.38482>;
            <D.38483>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34183 = D.30490->data.op[1].many_blocks;
            D.34184 = D.34183 + 8;
            D.34185 = *D.34184;
            if (D.34185 == 0B) goto <D.38488>; else goto <D.38482>;
            <D.38488>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34183 = D.30490->data.op[1].many_blocks;
            D.34184 = D.34183 + 8;
            *D.34184 = dont_throw;
            bblock.106 = cfg->cbb;
            mono_link_bblock (cfg, bblock.106, dont_throw);
            goto <D.38484>;
            <D.38482>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 == 0B) goto <D.38489>; else goto <D.38491>;
            <D.38491>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34177 = D.30490->opcode;
            if (D.34177 != 442) goto <D.38492>; else goto <D.38490>;
            <D.38492>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34177 = D.30490->opcode;
            if (D.34177 != 759) goto <D.38493>; else goto <D.38490>;
            <D.38493>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34177 = D.30490->opcode;
            D.34178 = D.34177 + 64985;
            if (D.34178 > 9) goto <D.38494>; else goto <D.38490>;
            <D.38494>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34177 = D.30490->opcode;
            D.34180 = D.34177 + 64878;
            if (D.34180 > 9) goto <D.38495>; else goto <D.38490>;
            <D.38495>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34177 = D.30490->opcode;
            D.34182 = D.34177 + 64888;
            if (D.34182 > 9) goto <D.38489>; else goto <D.38490>;
            <D.38489>:
            bblock.106 = cfg->cbb;
            mono_link_bblock (cfg, bblock.106, dont_throw);
            <D.38490>:
            <D.38484>:
            bblock.106 = cfg->cbb;
            bblock.106->next_bb = dont_throw;
            cfg->cbb = dont_throw;
            bblock.106 = cfg->cbb;
            bblock = bblock.106;
          }
          <D.38392>:
          <D.38390>:
          <D.38383>:
          <D.38380>:
          <D.38375>:
        }
        i = i + 1;
        <D.28013>:
        D.30555 = header->num_clauses;
        D.30556 = (int) D.30555;
        if (D.30556 > i) goto <D.28012>; else goto <D.28014>;
        <D.28014>:
        handlers = mono_find_final_block (cfg, ip, target, 2);
        if (handlers != 0B) goto <D.38496>; else goto <D.38497>;
        <D.38496>:
        {
          struct GList * tmp;
          struct MonoExceptionClause * clause;

          tmp = handlers;
          goto <D.28019>;
          <D.28018>:
          clause = tmp->data;
          D.30372 = cfg->cil_offset_to_bb;
          D.38498 = clause->handler_offset;
          D.38499 = (long unsigned int) D.38498;
          D.38500 = D.38499 * 8;
          D.38501 = D.30372 + D.38500;
          tblock = *D.38501;
          D.38502 = tblock == 0B;
          D.38503 = (long int) D.38502;
          D.38504 = __builtin_expect (D.38503, 0);
          if (D.38504 != 0) goto <D.38505>; else goto <D.38506>;
          <D.38505>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 10988, "tblock");
          <D.38506>:
          bblock.64 = bblock;
          link_bblock (cfg, bblock.64, tblock);
          D.30241 = cfg->mempool;
          ins = mono_mempool_alloc (D.30241, 80);
          ins->data.op[1].const_val = 0;
          D.30457 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.30457;
          ins->prev = 0B;
          D.30458 = ins->prev;
          ins->next = D.30458;
          ins->opcode = 735;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.30459 = ins->sreg3;
          ins->sreg2 = D.30459;
          D.30460 = ins->sreg2;
          ins->sreg1 = D.30460;
          D.30461 = cfg->ip;
          ins->cil_code = D.30461;
          ins->data.op[0].target_block = tblock;
          ins->data.op[1].exception_clause = clause;
          bblock.64 = bblock;
          D.30577 = bblock.64->last_ins;
          if (D.30577 != 0B) goto <D.38507>; else goto <D.38508>;
          <D.38507>:
          bblock.64 = bblock;
          D.30577 = bblock.64->last_ins;
          D.30577->next = ins;
          bblock.64 = bblock;
          D.30577 = bblock.64->last_ins;
          ins->prev = D.30577;
          bblock.64 = bblock;
          bblock.64->last_ins = ins;
          goto <D.38509>;
          <D.38508>:
          bblock.64 = bblock;
          bblock.64 = bblock;
          bblock.64->last_ins = ins;
          D.30577 = bblock.64->last_ins;
          bblock.64->code = D.30577;
          <D.38509>:
          bblock.64 = bblock;
          bblock.64->has_call_handler = 1;
          if (0 != 0) goto <D.38510>; else goto <D.38511>;
          <D.38510>:
          {
            struct MonoBasicBlock * target_bb;

            D.30372 = cfg->cil_offset_to_bb;
            target.123 = (long int) target;
            D.30377 = cfg->cil_start;
            D.30378 = (long int) D.30377;
            D.33624 = target.123 - D.30378;
            D.33625 = (long unsigned int) D.33624;
            D.33626 = D.33625 * 8;
            D.33627 = D.30372 + D.33626;
            target_bb = *D.33627;
            if (target_bb == 0B) goto <D.38512>; else goto <D.38513>;
            <D.38512>:
            if (target >= end) goto <D.38514>; else goto <D.38516>;
            <D.38516>:
            D.30388 = header->code;
            if (D.30388 > target) goto <D.38514>; else goto <D.38515>;
            <D.38514>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.38517>; else goto <D.38518>;
            <D.38517>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.38519>; else goto <D.38520>;
            <D.38519>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.38520>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.38518>:
            D.38521 = mini_get_debug_options ();
            D.38522 = D.38521->break_on_unverified;
            if (D.38522 != 0) goto <D.38523>; else goto unverified;
            <D.38523>:
            raise (5);
            <D.38515>:
            D.30241 = cfg->mempool;
            target_bb = mono_mempool_alloc0 (D.30241, 296);
            D.30349 = cfg->num_bblocks;
            D.38524 = D.30349;
            D.38525 = D.38524 + 1;
            cfg->num_bblocks = D.38525;
            D.38526 = (int) D.38524;
            target_bb->block_num = D.38526;
            target_bb->cil_code = target;
            D.38527 = target_bb->cil_code;
            if (D.38527 != 0B) goto <D.38528>; else goto <D.38529>;
            <D.38528>:
            D.30372 = cfg->cil_offset_to_bb;
            D.38527 = target_bb->cil_code;
            D.38530 = (long int) D.38527;
            D.30377 = cfg->cil_start;
            D.30378 = (long int) D.30377;
            D.38531 = D.38530 - D.30378;
            D.38532 = (long unsigned int) D.38531;
            D.38533 = D.38532 * 8;
            D.38534 = D.30372 + D.38533;
            *D.38534 = target_bb;
            <D.38529>:
            D.30408 = cfg->real_offset;
            target_bb->real_offset = D.30408;
            <D.38513>:
            link_bblock (cfg, tblock, target_bb);
          }
          <D.38511>:
          tmp = tmp->next;
          <D.28019>:
          if (tmp != 0B) goto <D.28018>; else goto <D.28020>;
          <D.28020>:
          monoeg_g_list_free (handlers);
        }
        <D.38497>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 442;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        if (D.30577 != 0B) goto <D.38535>; else goto <D.38536>;
        <D.38535>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        D.30577->next = ins;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        ins->prev = D.30577;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        goto <D.38537>;
        <D.38536>:
        bblock.64 = bblock;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        D.30577 = bblock.64->last_ins;
        bblock.64->code = D.30577;
        <D.38537>:
        D.30372 = cfg->cil_offset_to_bb;
        target.123 = (long int) target;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.33624 = target.123 - D.30378;
        D.33625 = (long unsigned int) D.33624;
        D.33626 = D.33625 * 8;
        D.33627 = D.30372 + D.33626;
        tblock = *D.33627;
        if (tblock == 0B) goto <D.38538>; else goto <D.38539>;
        <D.38538>:
        if (target >= end) goto <D.38540>; else goto <D.38542>;
        <D.38542>:
        D.30388 = header->code;
        if (D.30388 > target) goto <D.38540>; else goto <D.38541>;
        <D.38540>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.38543>; else goto <D.38544>;
        <D.38543>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.38545>; else goto <D.38546>;
        <D.38545>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.38546>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38544>:
        D.38547 = mini_get_debug_options ();
        D.38548 = D.38547->break_on_unverified;
        if (D.38548 != 0) goto <D.38549>; else goto unverified;
        <D.38549>:
        raise (5);
        <D.38541>:
        D.30241 = cfg->mempool;
        tblock = mono_mempool_alloc0 (D.30241, 296);
        D.30349 = cfg->num_bblocks;
        D.38550 = D.30349;
        D.38551 = D.38550 + 1;
        cfg->num_bblocks = D.38551;
        D.38552 = (int) D.38550;
        tblock->block_num = D.38552;
        tblock->cil_code = target;
        D.30437 = tblock->cil_code;
        if (D.30437 != 0B) goto <D.38553>; else goto <D.38554>;
        <D.38553>:
        D.30372 = cfg->cil_offset_to_bb;
        D.30437 = tblock->cil_code;
        D.30440 = (long int) D.30437;
        D.30377 = cfg->cil_start;
        D.30378 = (long int) D.30377;
        D.30441 = D.30440 - D.30378;
        D.30442 = (long unsigned int) D.30441;
        D.30443 = D.30442 * 8;
        D.30444 = D.30372 + D.30443;
        *D.30444 = tblock;
        <D.38554>:
        D.30408 = cfg->real_offset;
        tblock->real_offset = D.30408;
        <D.38539>:
        bblock.64 = bblock;
        link_bblock (cfg, bblock.64, tblock);
        ins->data.op[0].target_block = tblock;
        start_new_bblock = 1;
        D.31121 = *ip;
        if (D.31121 == 221) goto <D.38555>; else goto <D.38556>;
        <D.38555>:
        ip = ip + 5;
        goto <D.38557>;
        <D.38556>:
        ip = ip + 2;
        <D.38557>:
        goto <D.27394>;
      }
      <D.28021>:
      D.30183 = BIT_FIELD_REF <*method, 64, 256>;
      D.30184 = D.30183 & 4467570830351532032;
      D.38558 = D.30184 == 0;
      D.38559 = (long int) D.38558;
      D.38560 = __builtin_expect (D.38559, 0);
      if (D.38560 != 0) goto <D.38561>; else goto <D.38562>;
      <D.38561>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11030, "method->wrapper_type != MONO_WRAPPER_NONE");
      <D.38562>:
      D.31251 = ip + 2;
      if (D.31251 > end) goto <D.38563>; else goto <D.38564>;
      <D.38563>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.38565>; else goto <D.38566>;
      <D.38565>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.38567>; else goto <D.38568>;
      <D.38567>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.38568>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.38566>:
      D.38569 = mini_get_debug_options ();
      D.38570 = D.38569->break_on_unverified;
      if (D.38570 != 0) goto <D.38571>; else goto unverified;
      <D.38571>:
      raise (5);
      <D.38564>:
      D.31270 = ip + 1;
      D.31271 = *D.31270;
      D.31579 = (int) D.31271;
      switch (D.31579) <default: <D.28080>, case 0: <D.28022>, case 1: <D.28043>, case 2: <D.28027>, case 3: <D.28035>, case 4: <D.28040>, case 5: <D.28050>, case 6: <D.28044>, case 7: <D.28053>, case 8: <D.28054>, case 9: <D.28056>, case 10: <D.28057>, case 11: <D.28058>, case 12: <D.28059>, case 13: <D.28060>, case 14: <D.28032>, case 15: <D.28062>, case 16: <D.28064>, case 17: <D.28065>, case 18: <D.28078>, case 19: <D.28029>>
      <D.28022>:
      {
        void * func;
        struct MonoJitICallInfo * info;

        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38573 = D.38572 << 24;
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38574 = D.38572 >> 8;
        D.38575 = D.38574 & 65280;
        D.38576 = D.38573 | D.38575;
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38577 = D.38572 << 8;
        D.38578 = D.38577 & 16711680;
        D.38579 = D.38576 | D.38578;
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38580 = D.38572 >> 24;
        token = D.38579 | D.38580;
        func = mono_method_get_wrapper_data (method, token);
        info = mono_find_jit_icall_by_addr (func);
        if (info == 0B) goto <D.38581>; else goto <D.38582>;
        <D.38581>:
        D.38583 = mono_method_full_name (method, 1);
        monoeg_g_log (0B, 4, "Could not find icall address in wrapper %s", D.38583);
        <D.28025>:
        goto <D.28025>;
        <D.38582>:
        D.38584 = info == 0B;
        D.38585 = (long int) D.38584;
        D.38586 = __builtin_expect (D.38585, 0);
        if (D.38586 != 0) goto <D.38587>; else goto <D.38588>;
        <D.38587>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11043, "info");
        <D.38588>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        D.31014 = D.31013 /[ex] 8;
        D.38589 = info->sig;
        D.38590 = D.38589->param_count;
        D.38591 = (long int) D.38590;
        if (D.31014 < D.38591) goto <D.38592>; else goto <D.38593>;
        <D.38592>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.38594>; else goto <D.38595>;
        <D.38594>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.38596>; else goto <D.38597>;
        <D.38596>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.38597>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38595>:
        D.38598 = mini_get_debug_options ();
        D.38599 = D.38598->break_on_unverified;
        if (D.38599 != 0) goto <D.38600>; else goto unverified;
        <D.38600>:
        raise (5);
        <D.38593>:
        D.38589 = info->sig;
        D.38590 = D.38589->param_count;
        D.38601 = (long unsigned int) D.38590;
        D.38602 = D.38601 * 8;
        D.38603 = -D.38602;
        sp = sp + D.38603;
        D.38604 = info->func;
        ins = mono_emit_jit_icall (cfg, D.38604, sp);
        D.38589 = info->sig;
        D.38605 = D.38589->ret;
        D.38606 = mono_type_is_void (D.38605);
        if (D.38606 == 0) goto <D.38607>; else goto <D.38608>;
        <D.38607>:
        sp.263 = sp;
        sp = sp.263 + 8;
        *sp.263 = ins;
        <D.38608>:
        ip = ip + 6;
        num_calls.264 = num_calls;
        num_calls = num_calls.264 + 1;
        D.38611 = num_calls.264 * 10;
        inline_costs = D.38611 + inline_costs;
        goto <D.28026>;
      }
      <D.28027>:
      {
        void * ptr;

        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        D.31014 = D.31013 /[ex] 8;
        D.30924 = header->max_stack;
        D.31146 = (long int) D.30924;
        if (D.31014 >= D.31146) goto <D.38612>; else goto <D.38613>;
        <D.38612>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.38614>; else goto <D.38615>;
        <D.38614>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.38616>; else goto <D.38617>;
        <D.38616>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.38617>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38615>:
        D.38618 = mini_get_debug_options ();
        D.38619 = D.38618->break_on_unverified;
        if (D.38619 != 0) goto <D.38620>; else goto unverified;
        <D.38620>:
        raise (5);
        <D.38613>:
        D.34754 = ip + 6;
        if (D.34754 > end) goto <D.38621>; else goto <D.38622>;
        <D.38621>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.38623>; else goto <D.38624>;
        <D.38623>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.38625>; else goto <D.38626>;
        <D.38625>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.38626>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38624>:
        D.38627 = mini_get_debug_options ();
        D.38628 = D.38627->break_on_unverified;
        if (D.38628 != 0) goto <D.38629>; else goto unverified;
        <D.38629>:
        raise (5);
        <D.38622>:
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38573 = D.38572 << 24;
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38574 = D.38572 >> 8;
        D.38575 = D.38574 & 65280;
        D.38576 = D.38573 | D.38575;
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38577 = D.38572 << 8;
        D.38578 = D.38577 & 16711680;
        D.38579 = D.38576 | D.38578;
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38580 = D.38572 >> 24;
        token = D.38579 | D.38580;
        ptr = mono_method_get_wrapper_data (method, token);
        D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.30635 = D.30634 & 33554432;
        if (D.30635 != 0) goto <D.38630>; else goto <D.38631>;
        <D.38630>:
        D.38632 = mono_thread_interruption_request_flag ();
        if (D.38632 == ptr) goto <D.38633>; else goto <D.38634>;
        <D.38633>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.30635 = D.30634 & 33554432;
        if (D.30635 != 0) goto <D.38636>; else goto <D.38637>;
        <D.38636>:
        iftmp.265 = 732;
        goto <D.38638>;
        <D.38637>:
        iftmp.265 = 363;
        <D.38638>:
        ins->opcode = iftmp.265;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        ins->data.op[0].p = 0B;
        ins->data.op[1].src = 33B;
        ins->type = 3;
        D.38639 = alloc_dreg (cfg, 3);
        D.38640 = (int) D.38639;
        ins->dreg = D.38640;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.38641>; else goto <D.38642>;
        <D.38641>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.38643>;
        <D.38642>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.38643>:
        sp.266 = sp;
        sp = sp.266 + 8;
        *sp.266 = ins;
        ip = ip + 6;
        goto <D.28026>;
        <D.38634>:
        <D.38631>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 363;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        ins->data.op[0].p = ptr;
        ins->type = 3;
        D.38645 = alloc_dreg (cfg, 3);
        D.38646 = (int) D.38645;
        ins->dreg = D.38646;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.38647>; else goto <D.38648>;
        <D.38647>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.38649>;
        <D.38648>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.38649>:
        sp.267 = sp;
        sp = sp.267 + 8;
        *sp.267 = ins;
        ip = ip + 6;
        num_calls.268 = num_calls;
        num_calls = num_calls.268 + 1;
        D.38652 = num_calls.268 * 10;
        inline_costs = D.38652 + inline_costs;
        D.30322 = cfg->verbose_level;
        if (D.30322 > 1) goto <D.38653>; else goto <D.38654>;
        <D.38653>:
        printf ("AOT disabled: %s:%d\n", "method-to-ir.c", 11077);
        <D.38654>:
        cfg->disable_aot = 1;
        goto <D.28026>;
      }
      <D.28029>:
      {
        struct MonoJitICallInfo * callinfo;
        void * ptr;

        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        D.31014 = D.31013 /[ex] 8;
        D.30924 = header->max_stack;
        D.31146 = (long int) D.30924;
        if (D.31014 >= D.31146) goto <D.38655>; else goto <D.38656>;
        <D.38655>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.38657>; else goto <D.38658>;
        <D.38657>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.38659>; else goto <D.38660>;
        <D.38659>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.38660>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38658>:
        D.38661 = mini_get_debug_options ();
        D.38662 = D.38661->break_on_unverified;
        if (D.38662 != 0) goto <D.38663>; else goto unverified;
        <D.38663>:
        raise (5);
        <D.38656>:
        D.34754 = ip + 6;
        if (D.34754 > end) goto <D.38664>; else goto <D.38665>;
        <D.38664>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.38666>; else goto <D.38667>;
        <D.38666>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.38668>; else goto <D.38669>;
        <D.38668>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.38669>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38667>:
        D.38670 = mini_get_debug_options ();
        D.38671 = D.38670->break_on_unverified;
        if (D.38671 != 0) goto <D.38672>; else goto unverified;
        <D.38672>:
        raise (5);
        <D.38665>:
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38573 = D.38572 << 24;
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38574 = D.38572 >> 8;
        D.38575 = D.38574 & 65280;
        D.38576 = D.38573 | D.38575;
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38577 = D.38572 << 8;
        D.38578 = D.38577 & 16711680;
        D.38579 = D.38576 | D.38578;
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38580 = D.38572 >> 24;
        token = D.38579 | D.38580;
        ptr = mono_method_get_wrapper_data (method, token);
        callinfo = mono_find_jit_icall_by_addr (ptr);
        D.38673 = callinfo == 0B;
        D.38674 = (long int) D.38673;
        D.38675 = __builtin_expect (D.38674, 0);
        if (D.38675 != 0) goto <D.38676>; else goto <D.38677>;
        <D.38676>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11090, "callinfo");
        <D.38677>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.30635 = D.30634 & 33554432;
        if (D.30635 != 0) goto <D.38679>; else goto <D.38680>;
        <D.38679>:
        iftmp.269 = 732;
        goto <D.38681>;
        <D.38680>:
        iftmp.269 = 363;
        <D.38681>:
        ins->opcode = iftmp.269;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        D.38682 = callinfo->name;
        ins->data.op[0].p = D.38682;
        ins->data.op[1].src = 32B;
        ins->type = 3;
        D.38683 = alloc_dreg (cfg, 3);
        D.38684 = (int) D.38683;
        ins->dreg = D.38684;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.38685>; else goto <D.38686>;
        <D.38685>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.38687>;
        <D.38686>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.38687>:
        sp.270 = sp;
        sp = sp.270 + 8;
        *sp.270 = ins;
        ip = ip + 6;
        num_calls.271 = num_calls;
        num_calls = num_calls.271 + 1;
        D.38690 = num_calls.271 * 10;
        inline_costs = D.38690 + inline_costs;
        goto <D.28026>;
      }
      <D.28032>:
      {
        struct MonoMethod * cmethod;
        void * ptr;

        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        D.31014 = D.31013 /[ex] 8;
        D.30924 = header->max_stack;
        D.31146 = (long int) D.30924;
        if (D.31014 >= D.31146) goto <D.38691>; else goto <D.38692>;
        <D.38691>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.38693>; else goto <D.38694>;
        <D.38693>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.38695>; else goto <D.38696>;
        <D.38695>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.38696>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38694>:
        D.38697 = mini_get_debug_options ();
        D.38698 = D.38697->break_on_unverified;
        if (D.38698 != 0) goto <D.38699>; else goto unverified;
        <D.38699>:
        raise (5);
        <D.38692>:
        D.34754 = ip + 6;
        if (D.34754 > end) goto <D.38700>; else goto <D.38701>;
        <D.38700>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.38702>; else goto <D.38703>;
        <D.38702>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.38704>; else goto <D.38705>;
        <D.38704>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.38705>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38703>:
        D.38706 = mini_get_debug_options ();
        D.38707 = D.38706->break_on_unverified;
        if (D.38707 != 0) goto <D.38708>; else goto unverified;
        <D.38708>:
        raise (5);
        <D.38701>:
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38573 = D.38572 << 24;
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38574 = D.38572 >> 8;
        D.38575 = D.38574 & 65280;
        D.38576 = D.38573 | D.38575;
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38577 = D.38572 << 8;
        D.38578 = D.38577 & 16711680;
        D.38579 = D.38576 | D.38578;
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38580 = D.38572 >> 24;
        token = D.38579 | D.38580;
        cmethod = mono_method_get_wrapper_data (method, token);
        D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.30635 = D.30634 & 33554432;
        if (D.30635 != 0) goto <D.38709>; else goto <D.38710>;
        <D.38709>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.30635 = D.30634 & 33554432;
        if (D.30635 != 0) goto <D.38712>; else goto <D.38713>;
        <D.38712>:
        iftmp.272 = 732;
        goto <D.38714>;
        <D.38713>:
        iftmp.272 = 363;
        <D.38714>:
        ins->opcode = iftmp.272;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        ins->data.op[0].p = cmethod;
        ins->data.op[1].src = 31B;
        ins->type = 3;
        D.38715 = alloc_dreg (cfg, 3);
        D.38716 = (int) D.38715;
        ins->dreg = D.38716;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.38717>; else goto <D.38718>;
        <D.38717>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.38719>;
        <D.38718>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.38719>:
        goto <D.38720>;
        <D.38710>:
        ptr = mono_lookup_internal_call (cmethod);
        D.38721 = ptr == 0B;
        D.38722 = (long int) D.38721;
        D.38723 = __builtin_expect (D.38722, 0);
        if (D.38723 != 0) goto <D.38724>; else goto <D.38725>;
        <D.38724>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11111, "ptr");
        <D.38725>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 363;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        ins->data.op[0].p = ptr;
        ins->type = 3;
        D.38726 = alloc_dreg (cfg, 3);
        D.38727 = (int) D.38726;
        ins->dreg = D.38727;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.38728>; else goto <D.38729>;
        <D.38728>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.38730>;
        <D.38729>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.38730>:
        <D.38720>:
        sp.273 = sp;
        sp = sp.273 + 8;
        *sp.273 = ins;
        ip = ip + 6;
        goto <D.28026>;
      }
      <D.28035>:
      {
        struct MonoInst * src_var;
        struct MonoInst * src;

        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        if (D.31013 <= 7) goto <D.38732>; else goto <D.38733>;
        <D.38732>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.38734>; else goto <D.38735>;
        <D.38734>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.38736>; else goto <D.38737>;
        <D.38736>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.38737>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.38735>:
        D.38738 = mini_get_debug_options ();
        D.38739 = D.38738->break_on_unverified;
        if (D.38739 != 0) goto <D.38740>; else goto unverified;
        <D.38740>:
        raise (5);
        <D.38733>:
        sp = sp + 18446744073709551608;
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        D.36366 = (unsigned int) D.31422;
        D.31341 = cfg->vreg_to_inst_len;
        if (D.36366 < D.31341) goto <D.38742>; else goto <D.38743>;
        <D.38742>:
        D.31344 = cfg->vreg_to_inst;
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        D.36369 = (long unsigned int) D.31422;
        D.36370 = D.36369 * 8;
        D.36371 = D.31344 + D.36370;
        iftmp.274 = *D.36371;
        goto <D.38744>;
        <D.38743>:
        iftmp.274 = 0B;
        <D.38744>:
        src_var = iftmp.274;
        D.30241 = cfg->mempool;
        src = mono_mempool_alloc (D.30241, 80);
        src->data.op[1].const_val = 0;
        D.38745 = src->data.op[1].const_val;
        src->data.op[0].const_val = D.38745;
        src->prev = 0B;
        D.38746 = src->prev;
        src->next = D.38746;
        src->opcode = 314;
        src->flags = 0;
        src->type = 0;
        src->dreg = -1;
        src->sreg3 = -1;
        D.38747 = src->sreg3;
        src->sreg2 = D.38747;
        D.38748 = src->sreg2;
        src->sreg1 = D.38748;
        D.30461 = cfg->ip;
        src->cil_code = D.30461;
        src->data.op[0].p = src_var;
        D.38749 = src_var->flags;
        D.38750 = D.38749 | 16;
        src_var->flags = D.38750;
        src->type = 5;
        D.38751 = src_var->klass;
        src->klass = D.38751;
        D.38752 = alloc_dreg (cfg, 5);
        D.38753 = (int) D.38752;
        src->dreg = D.38753;
        cfg->has_indirection = 1;
        D.30389 = cfg->gsharedvt;
        D.31326 = D.30389 != 0;
        D.31327 = (long int) D.31326;
        D.31328 = __builtin_expect (D.31327, 0);
        if (D.31328 != 0) goto <D.38754>; else goto <D.38755>;
        <D.38754>:
        D.38756 = src_var->data.op[1].vtype;
        D.38757 = mini_is_gsharedvt_variable_type (cfg, D.38756);
        if (D.38757 != 0) goto <D.38758>; else goto <D.38759>;
        <D.38758>:
        handle_gsharedvt_ldaddr (cfg);
        <D.38759>:
        <D.38755>:
        if (0 != 0) goto <D.38760>; else goto <D.38761>;
        <D.38760>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.38763 = src_var->dreg;
          D.38764 = D.38763 + 1;
          D.38765 = (unsigned int) D.38764;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.38765 < D.31341) goto <D.38766>; else goto <D.38767>;
          <D.38766>:
          D.31344 = cfg->vreg_to_inst;
          D.38763 = src_var->dreg;
          D.38768 = (sizetype) D.38763;
          D.38769 = D.38768 + 1;
          D.38770 = D.38769 * 8;
          D.38771 = D.31344 + D.38770;
          iftmp.275 = *D.38771;
          goto <D.38772>;
          <D.38767>:
          iftmp.275 = 0B;
          <D.38772>:
          var1 = iftmp.275;
          D.38763 = src_var->dreg;
          D.38774 = D.38763 + 2;
          D.38775 = (unsigned int) D.38774;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.38775 < D.31341) goto <D.38776>; else goto <D.38777>;
          <D.38776>:
          D.31344 = cfg->vreg_to_inst;
          D.38763 = src_var->dreg;
          D.38768 = (sizetype) D.38763;
          D.38778 = D.38768 + 2;
          D.38779 = D.38778 * 8;
          D.38780 = D.31344 + D.38779;
          iftmp.276 = *D.38780;
          goto <D.38781>;
          <D.38777>:
          iftmp.276 = 0B;
          <D.38781>:
          var2 = iftmp.276;
          D.38782 = var1 == 0B;
          D.38783 = (long int) D.38782;
          D.38784 = __builtin_expect (D.38783, 0);
          if (D.38784 != 0) goto <D.38785>; else goto <D.38786>;
          <D.38785>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11126, "var1");
          <D.38786>:
          D.38787 = var2 == 0B;
          D.38788 = (long int) D.38787;
          D.38789 = __builtin_expect (D.38788, 0);
          if (D.38789 != 0) goto <D.38790>; else goto <D.38791>;
          <D.38790>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11126, "var2");
          <D.38791>:
          D.38792 = var1->flags;
          D.38793 = D.38792 | 16;
          var1->flags = D.38793;
          D.38794 = var2->flags;
          D.38795 = D.38794 | 16;
          var2->flags = D.38795;
        }
        <D.38761>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.38796>; else goto <D.38797>;
        <D.38796>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = src;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        src->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = src;
        goto <D.38798>;
        <D.38797>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = src;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.38798>:
        sp.277 = sp;
        sp = sp.277 + 8;
        *sp.277 = src;
        ip = ip + 2;
        goto <D.28026>;
      }
      <D.28040>:
      {
        struct MonoInst * iargs[2];

        try
          {
            sp.71 = (long int) sp;
            stack_start.72 = (long int) stack_start;
            D.31013 = sp.71 - stack_start.72;
            D.31014 = D.31013 /[ex] 8;
            D.30924 = header->max_stack;
            D.31146 = (long int) D.30924;
            if (D.31014 >= D.31146) goto <D.38800>; else goto <D.38801>;
            <D.38800>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.38802>; else goto <D.38803>;
            <D.38802>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.38804>; else goto <D.38805>;
            <D.38804>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.38805>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.38803>:
            D.38806 = mini_get_debug_options ();
            D.38807 = D.38806->break_on_unverified;
            if (D.38807 != 0) goto <D.38808>; else goto unverified;
            <D.38808>:
            raise (5);
            <D.38801>:
            D.34754 = ip + 6;
            if (D.34754 > end) goto <D.38809>; else goto <D.38810>;
            <D.38809>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.38811>; else goto <D.38812>;
            <D.38811>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.38813>; else goto <D.38814>;
            <D.38813>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.38814>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.38812>:
            D.38815 = mini_get_debug_options ();
            D.38816 = D.38815->break_on_unverified;
            if (D.38816 != 0) goto <D.38817>; else goto unverified;
            <D.38817>:
            raise (5);
            <D.38810>:
            D.31251 = ip + 2;
            D.38572 = MEM[(const guint32 *)D.31251];
            D.38573 = D.38572 << 24;
            D.31251 = ip + 2;
            D.38572 = MEM[(const guint32 *)D.31251];
            D.38574 = D.38572 >> 8;
            D.38575 = D.38574 & 65280;
            D.38576 = D.38573 | D.38575;
            D.31251 = ip + 2;
            D.38572 = MEM[(const guint32 *)D.31251];
            D.38577 = D.38572 << 8;
            D.38578 = D.38577 & 16711680;
            D.38579 = D.38576 | D.38578;
            D.31251 = ip + 2;
            D.38572 = MEM[(const guint32 *)D.31251];
            D.38580 = D.38572 >> 24;
            token = D.38579 | D.38580;
            klass.278 = mono_method_get_wrapper_data (method, token);
            klass = klass.278;
            klass.144 = klass;
            mono_class_init (klass.144);
            D.30632 = cfg->opt;
            D.30633 = D.30632 & 512;
            if (D.30633 != 0) goto <D.38819>; else goto <D.38822>;
            <D.38822>:
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.38819>; else goto <D.38820>;
            <D.38819>:
            {
              struct MonoInst * __domain_var;

              __domain_var = mono_get_domainvar (cfg);
              D.30241 = cfg->mempool;
              D.38823 = mono_mempool_alloc (D.30241, 80);
              iargs[0] = D.38823;
              D.38824 = iargs[0];
              D.38824 = iargs[0];
              D.38824->data.op[1].const_val = 0;
              D.38825 = D.38824->data.op[1].const_val;
              D.38824->data.op[0].const_val = D.38825;
              D.38824 = iargs[0];
              D.38824 = iargs[0];
              D.38824->prev = 0B;
              D.38826 = D.38824->prev;
              D.38824->next = D.38826;
              D.38824 = iargs[0];
              D.38824->opcode = 424;
              D.38824 = iargs[0];
              D.38824->flags = 0;
              D.38824 = iargs[0];
              D.38824->type = 0;
              D.38824 = iargs[0];
              D.38824->dreg = -1;
              D.38824 = iargs[0];
              D.38824 = iargs[0];
              D.38824 = iargs[0];
              D.38824->sreg3 = -1;
              D.38827 = D.38824->sreg3;
              D.38824->sreg2 = D.38827;
              D.38828 = D.38824->sreg2;
              D.38824->sreg1 = D.38828;
              D.38824 = iargs[0];
              D.30461 = cfg->ip;
              D.38824->cil_code = D.30461;
              D.38824 = iargs[0];
              D.30978 = cfg->varinfo;
              D.38829 = __domain_var->data.op[0].const_val;
              D.38830 = (long unsigned int) D.38829;
              D.38831 = D.38830 * 8;
              D.38832 = D.30978 + D.38831;
              D.38833 = *D.38832;
              D.38834 = D.38833->data.op[1].vtype;
              D.38835 = mono_type_to_regmove (cfg, D.38834);
              D.38836 = (short unsigned int) D.38835;
              D.38824->opcode = D.38836;
              D.30978 = cfg->varinfo;
              D.38829 = __domain_var->data.op[0].const_val;
              D.38830 = (long unsigned int) D.38829;
              D.38831 = D.38830 * 8;
              D.38832 = D.30978 + D.38831;
              D.38833 = *D.38832;
              D.38834 = D.38833->data.op[1].vtype;
              D.38824 = iargs[0];
              type_to_eval_stack_type (cfg, D.38834, D.38824);
              D.38824 = iargs[0];
              D.30978 = cfg->varinfo;
              D.38829 = __domain_var->data.op[0].const_val;
              D.38830 = (long unsigned int) D.38829;
              D.38831 = D.38830 * 8;
              D.38832 = D.30978 + D.38831;
              D.38833 = *D.38832;
              D.38837 = D.38833->klass;
              D.38824->klass = D.38837;
              D.38824 = iargs[0];
              D.30978 = cfg->varinfo;
              D.38829 = __domain_var->data.op[0].const_val;
              D.38830 = (long unsigned int) D.38829;
              D.38831 = D.38830 * 8;
              D.38832 = D.30978 + D.38831;
              D.38833 = *D.38832;
              D.38838 = D.38833->dreg;
              D.38824->sreg1 = D.38838;
              D.38824 = iargs[0];
              D.38824 = iargs[0];
              D.38839 = D.38824->type;
              D.38840 = (<unnamed type>) D.38839;
              D.38841 = alloc_dreg (cfg, D.38840);
              D.38842 = (int) D.38841;
              D.38824->dreg = D.38842;
              D.38824 = iargs[0];
              D.38843 = D.38824->opcode;
              if (D.38843 == 427) goto <D.38844>; else goto <D.38845>;
              <D.38844>:
              D.38824 = iargs[0];
              D.30978 = cfg->varinfo;
              D.38829 = __domain_var->data.op[0].const_val;
              D.38830 = (long unsigned int) D.38829;
              D.38831 = D.38830 * 8;
              D.38832 = D.30978 + D.38831;
              D.38833 = *D.38832;
              D.38834 = D.38833->data.op[1].vtype;
              D.38846 = mono_class_from_mono_type (D.38834);
              D.38824->klass = D.38846;
              <D.38845>:
            }
            goto <D.38821>;
            <D.38820>:
            D.30241 = cfg->mempool;
            D.38847 = mono_mempool_alloc (D.30241, 80);
            iargs[0] = D.38847;
            D.38824 = iargs[0];
            D.38824 = iargs[0];
            D.38824->data.op[1].const_val = 0;
            D.38825 = D.38824->data.op[1].const_val;
            D.38824->data.op[0].const_val = D.38825;
            D.38824 = iargs[0];
            D.38824 = iargs[0];
            D.38824->prev = 0B;
            D.38826 = D.38824->prev;
            D.38824->next = D.38826;
            D.38824 = iargs[0];
            D.38824->opcode = 363;
            D.38824 = iargs[0];
            D.38824->flags = 0;
            D.38824 = iargs[0];
            D.38824->type = 0;
            D.38824 = iargs[0];
            D.38824->dreg = -1;
            D.38824 = iargs[0];
            D.38824 = iargs[0];
            D.38824 = iargs[0];
            D.38824->sreg3 = -1;
            D.38827 = D.38824->sreg3;
            D.38824->sreg2 = D.38827;
            D.38828 = D.38824->sreg2;
            D.38824->sreg1 = D.38828;
            D.38824 = iargs[0];
            D.30461 = cfg->ip;
            D.38824->cil_code = D.30461;
            D.38824 = iargs[0];
            D.30267 = cfg->domain;
            D.38824->data.op[0].p = D.30267;
            D.38824 = iargs[0];
            D.38824->type = 3;
            D.38824 = iargs[0];
            D.38848 = alloc_dreg (cfg, 3);
            D.38849 = (int) D.38848;
            D.38824->dreg = D.38849;
            <D.38821>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.38850>; else goto <D.38851>;
            <D.38850>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.38824 = iargs[0];
            D.30490->next = D.38824;
            D.38824 = iargs[0];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.38824->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.38824 = iargs[0];
            bblock.106->last_ins = D.38824;
            goto <D.38852>;
            <D.38851>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.38824 = iargs[0];
            bblock.106->last_ins = D.38824;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.38852>:
            D.30241 = cfg->mempool;
            D.38853 = mono_mempool_alloc (D.30241, 80);
            iargs[1] = D.38853;
            D.38854 = iargs[1];
            D.38854 = iargs[1];
            D.38854->data.op[1].const_val = 0;
            D.38855 = D.38854->data.op[1].const_val;
            D.38854->data.op[0].const_val = D.38855;
            D.38854 = iargs[1];
            D.38854 = iargs[1];
            D.38854->prev = 0B;
            D.38856 = D.38854->prev;
            D.38854->next = D.38856;
            D.38854 = iargs[1];
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.38858>; else goto <D.38859>;
            <D.38858>:
            iftmp.279 = 732;
            goto <D.38860>;
            <D.38859>:
            iftmp.279 = 363;
            <D.38860>:
            D.38854->opcode = iftmp.279;
            D.38854 = iargs[1];
            D.38854->flags = 0;
            D.38854 = iargs[1];
            D.38854->type = 0;
            D.38854 = iargs[1];
            D.38854->dreg = -1;
            D.38854 = iargs[1];
            D.38854 = iargs[1];
            D.38854 = iargs[1];
            D.38854->sreg3 = -1;
            D.38861 = D.38854->sreg3;
            D.38854->sreg2 = D.38861;
            D.38862 = D.38854->sreg2;
            D.38854->sreg1 = D.38862;
            D.38854 = iargs[1];
            D.30461 = cfg->ip;
            D.38854->cil_code = D.30461;
            D.38854 = iargs[1];
            klass.144 = klass;
            D.38854->data.op[0].p = klass.144;
            D.38854 = iargs[1];
            D.38854->data.op[1].src = 11B;
            D.38854 = iargs[1];
            D.38854->type = 3;
            D.38854 = iargs[1];
            D.38863 = alloc_dreg (cfg, 3);
            D.38864 = (int) D.38863;
            D.38854->dreg = D.38864;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.38865>; else goto <D.38866>;
            <D.38865>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.38854 = iargs[1];
            D.30490->next = D.38854;
            D.38854 = iargs[1];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.38854->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.38854 = iargs[1];
            bblock.106->last_ins = D.38854;
            goto <D.38867>;
            <D.38866>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.38854 = iargs[1];
            bblock.106->last_ins = D.38854;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.38867>:
            sp.280 = sp;
            sp = sp.280 + 8;
            D.38869 = mono_emit_jit_icall (cfg, mono_object_new, &iargs);
            *sp.280 = D.38869;
            ip = ip + 6;
            num_calls.281 = num_calls;
            num_calls = num_calls.281 + 1;
            D.38871 = num_calls.281 * 10;
            inline_costs = D.38871 + inline_costs;
            goto <D.28026>;
          }
        finally
          {
            iargs = {CLOBBER};
          }
      }
      <D.28043>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.38872>; else goto <D.38873>;
      <D.38872>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.38874>; else goto <D.38875>;
      <D.38874>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.38876>; else goto <D.38877>;
      <D.38876>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.38877>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.38875>:
      D.38878 = mini_get_debug_options ();
      D.38879 = D.38878->break_on_unverified;
      if (D.38879 != 0) goto <D.38880>; else goto unverified;
      <D.38880>:
      raise (5);
      <D.38873>:
      sp = sp + 18446744073709551608;
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.38881 = alloc_ireg_mp (cfg);
      D.38882 = (int) D.38881;
      ins->dreg = D.38882;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      ins->type = 5;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.38883>; else goto <D.38884>;
      <D.38883>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.38885>;
      <D.38884>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.38885>:
      sp.282 = sp;
      sp = sp.282 + 8;
      *sp.282 = ins;
      ip = ip + 2;
      goto <D.28026>;
      <D.28044>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.38887>; else goto <D.38888>;
      <D.38887>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.38889>; else goto <D.38890>;
      <D.38889>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.38891>; else goto <D.38892>;
      <D.38891>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.38892>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.38890>:
      D.38893 = mini_get_debug_options ();
      D.38894 = D.38893->break_on_unverified;
      if (D.38894 != 0) goto <D.38895>; else goto unverified;
      <D.38895>:
      raise (5);
      <D.38888>:
      D.34754 = ip + 6;
      if (D.34754 > end) goto <D.38896>; else goto <D.38897>;
      <D.38896>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.38898>; else goto <D.38899>;
      <D.38898>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.38900>; else goto <D.38901>;
      <D.38900>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.38901>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.38899>:
      D.38902 = mini_get_debug_options ();
      D.38903 = D.38902->break_on_unverified;
      if (D.38903 != 0) goto <D.38904>; else goto unverified;
      <D.38904>:
      raise (5);
      <D.38897>:
      sp = sp + 18446744073709551608;
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38573 = D.38572 << 24;
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38574 = D.38572 >> 8;
      D.38575 = D.38574 & 65280;
      D.38576 = D.38573 | D.38575;
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38577 = D.38572 << 8;
      D.38578 = D.38577 & 16711680;
      D.38579 = D.38576 | D.38578;
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38580 = D.38572 >> 24;
      token = D.38579 | D.38580;
      klass.283 = mono_method_get_wrapper_data (method, token);
      klass = klass.283;
      klass.144 = klass;
      D.35477 = BIT_FIELD_REF <*klass.144, 64, 256>;
      D.36123 = D.35477 & 1152921504606846976;
      D.38906 = D.36123 == 0;
      D.38907 = (long int) D.38906;
      D.38908 = __builtin_expect (D.38907, 0);
      if (D.38908 != 0) goto <D.38909>; else goto <D.38910>;
      <D.38909>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11169, "klass->valuetype");
      <D.38910>:
      klass.144 = klass;
      mono_class_init (klass.144);
      {
        struct MonoInst * src;
        struct MonoInst * dest;
        struct MonoInst * temp;

        src = *sp;
        klass.144 = klass;
        D.34771 = &klass.144->byval_arg;
        temp = mono_compile_create_var (cfg, D.34771, 329);
        temp->backend.is_pinvoke = 1;
        D.30241 = cfg->mempool;
        dest = mono_mempool_alloc (D.30241, 80);
        dest->data.op[1].const_val = 0;
        D.38911 = dest->data.op[1].const_val;
        dest->data.op[0].const_val = D.38911;
        dest->prev = 0B;
        D.38912 = dest->prev;
        dest->next = D.38912;
        dest->opcode = 314;
        dest->flags = 0;
        dest->type = 0;
        dest->dreg = -1;
        dest->sreg3 = -1;
        D.38913 = dest->sreg3;
        dest->sreg2 = D.38913;
        D.38914 = dest->sreg2;
        dest->sreg1 = D.38914;
        D.30461 = cfg->ip;
        dest->cil_code = D.30461;
        D.30978 = cfg->varinfo;
        D.38915 = temp->data.op[0].const_val;
        D.38916 = (long unsigned int) D.38915;
        D.38917 = D.38916 * 8;
        D.38918 = D.30978 + D.38917;
        D.38919 = *D.38918;
        dest->data.op[0].p = D.38919;
        D.30978 = cfg->varinfo;
        D.38915 = temp->data.op[0].const_val;
        D.38916 = (long unsigned int) D.38915;
        D.38917 = D.38916 * 8;
        D.38918 = D.30978 + D.38917;
        D.38919 = *D.38918;
        D.30978 = cfg->varinfo;
        D.38915 = temp->data.op[0].const_val;
        D.38916 = (long unsigned int) D.38915;
        D.38917 = D.38916 * 8;
        D.38918 = D.30978 + D.38917;
        D.38919 = *D.38918;
        D.38920 = D.38919->flags;
        D.38921 = D.38920 | 16;
        D.38919->flags = D.38921;
        dest->type = 5;
        D.30978 = cfg->varinfo;
        D.38915 = temp->data.op[0].const_val;
        D.38916 = (long unsigned int) D.38915;
        D.38917 = D.38916 * 8;
        D.38918 = D.30978 + D.38917;
        D.38919 = *D.38918;
        D.38922 = D.38919->klass;
        dest->klass = D.38922;
        D.38923 = alloc_dreg (cfg, 5);
        D.38924 = (int) D.38923;
        dest->dreg = D.38924;
        cfg->has_indirection = 1;
        D.30389 = cfg->gsharedvt;
        D.31326 = D.30389 != 0;
        D.31327 = (long int) D.31326;
        D.31328 = __builtin_expect (D.31327, 0);
        if (D.31328 != 0) goto <D.38925>; else goto <D.38926>;
        <D.38925>:
        D.30978 = cfg->varinfo;
        D.38915 = temp->data.op[0].const_val;
        D.38916 = (long unsigned int) D.38915;
        D.38917 = D.38916 * 8;
        D.38918 = D.30978 + D.38917;
        D.38919 = *D.38918;
        D.38927 = D.38919->data.op[1].vtype;
        D.38928 = mini_is_gsharedvt_variable_type (cfg, D.38927);
        if (D.38928 != 0) goto <D.38929>; else goto <D.38930>;
        <D.38929>:
        handle_gsharedvt_ldaddr (cfg);
        <D.38930>:
        <D.38926>:
        if (0 != 0) goto <D.38931>; else goto <D.38932>;
        <D.38931>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.30978 = cfg->varinfo;
          D.38915 = temp->data.op[0].const_val;
          D.38916 = (long unsigned int) D.38915;
          D.38917 = D.38916 * 8;
          D.38918 = D.30978 + D.38917;
          D.38919 = *D.38918;
          D.38934 = D.38919->dreg;
          D.38935 = D.38934 + 1;
          D.38936 = (unsigned int) D.38935;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.38936 < D.31341) goto <D.38937>; else goto <D.38938>;
          <D.38937>:
          D.31344 = cfg->vreg_to_inst;
          D.30978 = cfg->varinfo;
          D.38915 = temp->data.op[0].const_val;
          D.38916 = (long unsigned int) D.38915;
          D.38917 = D.38916 * 8;
          D.38918 = D.30978 + D.38917;
          D.38919 = *D.38918;
          D.38934 = D.38919->dreg;
          D.38939 = (sizetype) D.38934;
          D.38940 = D.38939 + 1;
          D.38941 = D.38940 * 8;
          D.38942 = D.31344 + D.38941;
          iftmp.284 = *D.38942;
          goto <D.38943>;
          <D.38938>:
          iftmp.284 = 0B;
          <D.38943>:
          var1 = iftmp.284;
          D.30978 = cfg->varinfo;
          D.38915 = temp->data.op[0].const_val;
          D.38916 = (long unsigned int) D.38915;
          D.38917 = D.38916 * 8;
          D.38918 = D.30978 + D.38917;
          D.38919 = *D.38918;
          D.38934 = D.38919->dreg;
          D.38945 = D.38934 + 2;
          D.38946 = (unsigned int) D.38945;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.38946 < D.31341) goto <D.38947>; else goto <D.38948>;
          <D.38947>:
          D.31344 = cfg->vreg_to_inst;
          D.30978 = cfg->varinfo;
          D.38915 = temp->data.op[0].const_val;
          D.38916 = (long unsigned int) D.38915;
          D.38917 = D.38916 * 8;
          D.38918 = D.30978 + D.38917;
          D.38919 = *D.38918;
          D.38934 = D.38919->dreg;
          D.38939 = (sizetype) D.38934;
          D.38949 = D.38939 + 2;
          D.38950 = D.38949 * 8;
          D.38951 = D.31344 + D.38950;
          iftmp.285 = *D.38951;
          goto <D.38952>;
          <D.38948>:
          iftmp.285 = 0B;
          <D.38952>:
          var2 = iftmp.285;
          D.38953 = var1 == 0B;
          D.38954 = (long int) D.38953;
          D.38955 = __builtin_expect (D.38954, 0);
          if (D.38955 != 0) goto <D.38956>; else goto <D.38957>;
          <D.38956>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11178, "var1");
          <D.38957>:
          D.38958 = var2 == 0B;
          D.38959 = (long int) D.38958;
          D.38960 = __builtin_expect (D.38959, 0);
          if (D.38960 != 0) goto <D.38961>; else goto <D.38962>;
          <D.38961>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11178, "var2");
          <D.38962>:
          D.38963 = var1->flags;
          D.38964 = D.38963 | 16;
          var1->flags = D.38964;
          D.38965 = var2->flags;
          D.38966 = D.38965 | 16;
          var2->flags = D.38966;
        }
        <D.38932>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.38967>; else goto <D.38968>;
        <D.38967>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = dest;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        dest->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = dest;
        goto <D.38969>;
        <D.38968>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = dest;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.38969>:
        klass.144 = klass;
        mini_emit_stobj (cfg, dest, src, klass.144, 1);
        D.30241 = cfg->mempool;
        dest = mono_mempool_alloc (D.30241, 80);
        dest->data.op[1].const_val = 0;
        D.38911 = dest->data.op[1].const_val;
        dest->data.op[0].const_val = D.38911;
        dest->prev = 0B;
        D.38912 = dest->prev;
        dest->next = D.38912;
        dest->opcode = 424;
        dest->flags = 0;
        dest->type = 0;
        dest->dreg = -1;
        dest->sreg3 = -1;
        D.38913 = dest->sreg3;
        dest->sreg2 = D.38913;
        D.38914 = dest->sreg2;
        dest->sreg1 = D.38914;
        D.30461 = cfg->ip;
        dest->cil_code = D.30461;
        D.30978 = cfg->varinfo;
        D.38915 = temp->data.op[0].const_val;
        D.38916 = (long unsigned int) D.38915;
        D.38917 = D.38916 * 8;
        D.38918 = D.30978 + D.38917;
        D.38919 = *D.38918;
        D.38927 = D.38919->data.op[1].vtype;
        D.38970 = mono_type_to_regmove (cfg, D.38927);
        D.38971 = (short unsigned int) D.38970;
        dest->opcode = D.38971;
        D.30978 = cfg->varinfo;
        D.38915 = temp->data.op[0].const_val;
        D.38916 = (long unsigned int) D.38915;
        D.38917 = D.38916 * 8;
        D.38918 = D.30978 + D.38917;
        D.38919 = *D.38918;
        D.38927 = D.38919->data.op[1].vtype;
        type_to_eval_stack_type (cfg, D.38927, dest);
        D.30978 = cfg->varinfo;
        D.38915 = temp->data.op[0].const_val;
        D.38916 = (long unsigned int) D.38915;
        D.38917 = D.38916 * 8;
        D.38918 = D.30978 + D.38917;
        D.38919 = *D.38918;
        D.38922 = D.38919->klass;
        dest->klass = D.38922;
        D.30978 = cfg->varinfo;
        D.38915 = temp->data.op[0].const_val;
        D.38916 = (long unsigned int) D.38915;
        D.38917 = D.38916 * 8;
        D.38918 = D.30978 + D.38917;
        D.38919 = *D.38918;
        D.38934 = D.38919->dreg;
        dest->sreg1 = D.38934;
        D.38972 = dest->type;
        D.38973 = (<unnamed type>) D.38972;
        D.38974 = alloc_dreg (cfg, D.38973);
        D.38975 = (int) D.38974;
        dest->dreg = D.38975;
        D.38976 = dest->opcode;
        if (D.38976 == 427) goto <D.38977>; else goto <D.38978>;
        <D.38977>:
        D.30978 = cfg->varinfo;
        D.38915 = temp->data.op[0].const_val;
        D.38916 = (long unsigned int) D.38915;
        D.38917 = D.38916 * 8;
        D.38918 = D.30978 + D.38917;
        D.38919 = *D.38918;
        D.38927 = D.38919->data.op[1].vtype;
        D.38979 = mono_class_from_mono_type (D.38927);
        dest->klass = D.38979;
        <D.38978>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.38980>; else goto <D.38981>;
        <D.38980>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = dest;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        dest->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = dest;
        goto <D.38982>;
        <D.38981>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = dest;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.38982>:
        dest->type = 7;
        klass.144 = klass;
        dest->klass = klass.144;
        sp.286 = sp;
        sp = sp.286 + 8;
        *sp.286 = dest;
        ip = ip + 6;
      }
      goto <D.28026>;
      <D.28050>:
      D.33520 = cfg->ret;
      D.38984 = D.33520 == 0B;
      D.38985 = (long int) D.38984;
      D.38986 = __builtin_expect (D.38985, 0);
      if (D.38986 != 0) goto <D.38987>; else goto <D.38988>;
      <D.38987>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11194, "cfg->ret");
      <D.38988>:
      D.38989 = mono_method_signature (method);
      D.38990 = BIT_FIELD_REF <*D.38989, 64, 64>;
      D.38991 = D.38990 & 128;
      D.38992 = D.38991 == 0;
      D.38993 = (long int) D.38992;
      D.38994 = __builtin_expect (D.38993, 0);
      if (D.38994 != 0) goto <D.38995>; else goto <D.38996>;
      <D.38995>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11195, "mono_method_signature (method)->pinvoke");
      <D.38996>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.38997>; else goto <D.38998>;
      <D.38997>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.38999>; else goto <D.39000>;
      <D.38999>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39001>; else goto <D.39002>;
      <D.39001>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39002>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39000>:
      D.39003 = mini_get_debug_options ();
      D.39004 = D.39003->break_on_unverified;
      if (D.39004 != 0) goto <D.39005>; else goto unverified;
      <D.39005>:
      raise (5);
      <D.38998>:
      sp = sp + 18446744073709551608;
      D.34754 = ip + 6;
      if (D.34754 > end) goto <D.39006>; else goto <D.39007>;
      <D.39006>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.39008>; else goto <D.39009>;
      <D.39008>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39010>; else goto <D.39011>;
      <D.39010>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39011>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39009>:
      D.39012 = mini_get_debug_options ();
      D.39013 = D.39012->break_on_unverified;
      if (D.39013 != 0) goto <D.39014>; else goto unverified;
      <D.39014>:
      raise (5);
      <D.39007>:
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38573 = D.38572 << 24;
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38574 = D.38572 >> 8;
      D.38575 = D.38574 & 65280;
      D.38576 = D.38573 | D.38575;
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38577 = D.38572 << 8;
      D.38578 = D.38577 & 16711680;
      D.38579 = D.38576 | D.38578;
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38580 = D.38572 >> 24;
      token = D.38579 | D.38580;
      klass.287 = mono_method_get_wrapper_data (method, token);
      klass = klass.287;
      D.33562 = cfg->vret_addr;
      if (D.33562 == 0B) goto <D.39016>; else goto <D.39017>;
      <D.39016>:
      D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.39018 = D.30634 & 2097152;
      D.39019 = D.39018 == 0;
      D.39020 = (long int) D.39019;
      D.39021 = __builtin_expect (D.39020, 0);
      if (D.39021 != 0) goto <D.39022>; else goto <D.39023>;
      <D.39022>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11204, "cfg->ret_var_is_local");
      <D.39023>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 314;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.33520 = cfg->ret;
      ins->data.op[0].p = D.33520;
      D.33520 = cfg->ret;
      D.33520 = cfg->ret;
      D.39024 = D.33520->flags;
      D.39025 = D.39024 | 16;
      D.33520->flags = D.39025;
      ins->type = 5;
      D.33520 = cfg->ret;
      D.33571 = D.33520->klass;
      ins->klass = D.33571;
      D.39026 = alloc_dreg (cfg, 5);
      D.39027 = (int) D.39026;
      ins->dreg = D.39027;
      cfg->has_indirection = 1;
      D.30389 = cfg->gsharedvt;
      D.31326 = D.30389 != 0;
      D.31327 = (long int) D.31326;
      D.31328 = __builtin_expect (D.31327, 0);
      if (D.31328 != 0) goto <D.39028>; else goto <D.39029>;
      <D.39028>:
      D.33520 = cfg->ret;
      D.39030 = D.33520->data.op[1].vtype;
      D.39031 = mini_is_gsharedvt_variable_type (cfg, D.39030);
      if (D.39031 != 0) goto <D.39032>; else goto <D.39033>;
      <D.39032>:
      handle_gsharedvt_ldaddr (cfg);
      <D.39033>:
      <D.39029>:
      if (0 != 0) goto <D.39034>; else goto <D.39035>;
      <D.39034>:
      {
        struct MonoInst * var1;
        struct MonoInst * var2;

        D.33520 = cfg->ret;
        D.33572 = D.33520->dreg;
        D.39037 = D.33572 + 1;
        D.39038 = (unsigned int) D.39037;
        D.31341 = cfg->vreg_to_inst_len;
        if (D.39038 < D.31341) goto <D.39039>; else goto <D.39040>;
        <D.39039>:
        D.31344 = cfg->vreg_to_inst;
        D.33520 = cfg->ret;
        D.33572 = D.33520->dreg;
        D.39041 = (sizetype) D.33572;
        D.39042 = D.39041 + 1;
        D.39043 = D.39042 * 8;
        D.39044 = D.31344 + D.39043;
        iftmp.288 = *D.39044;
        goto <D.39045>;
        <D.39040>:
        iftmp.288 = 0B;
        <D.39045>:
        var1 = iftmp.288;
        D.33520 = cfg->ret;
        D.33572 = D.33520->dreg;
        D.39047 = D.33572 + 2;
        D.39048 = (unsigned int) D.39047;
        D.31341 = cfg->vreg_to_inst_len;
        if (D.39048 < D.31341) goto <D.39049>; else goto <D.39050>;
        <D.39049>:
        D.31344 = cfg->vreg_to_inst;
        D.33520 = cfg->ret;
        D.33572 = D.33520->dreg;
        D.39041 = (sizetype) D.33572;
        D.39051 = D.39041 + 2;
        D.39052 = D.39051 * 8;
        D.39053 = D.31344 + D.39052;
        iftmp.289 = *D.39053;
        goto <D.39054>;
        <D.39050>:
        iftmp.289 = 0B;
        <D.39054>:
        var2 = iftmp.289;
        D.39055 = var1 == 0B;
        D.39056 = (long int) D.39055;
        D.39057 = __builtin_expect (D.39056, 0);
        if (D.39057 != 0) goto <D.39058>; else goto <D.39059>;
        <D.39058>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11206, "var1");
        <D.39059>:
        D.39060 = var2 == 0B;
        D.39061 = (long int) D.39060;
        D.39062 = __builtin_expect (D.39061, 0);
        if (D.39062 != 0) goto <D.39063>; else goto <D.39064>;
        <D.39063>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11206, "var2");
        <D.39064>:
        D.39065 = var1->flags;
        D.39066 = D.39065 | 16;
        var1->flags = D.39066;
        D.39067 = var2->flags;
        D.39068 = D.39067 | 16;
        var2->flags = D.39068;
      }
      <D.39035>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.39069>; else goto <D.39070>;
      <D.39069>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.39071>;
      <D.39070>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.39071>:
      goto <D.39072>;
      <D.39017>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      ins->type = 5;
      D.33520 = cfg->ret;
      D.33571 = D.33520->klass;
      ins->klass = D.33571;
      D.33562 = cfg->vret_addr;
      D.33585 = D.33562->dreg;
      ins->sreg1 = D.33585;
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.39073 = alloc_dreg (cfg, D.30989);
      D.39074 = (int) D.39073;
      ins->dreg = D.39074;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.39075>; else goto <D.39076>;
      <D.39075>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.39077>;
      <D.39076>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.39077>:
      <D.39072>:
      D.31240 = *sp;
      klass.144 = klass;
      mini_emit_stobj (cfg, ins, D.31240, klass.144, 1);
      if (sp != stack_start) goto <D.39078>; else goto <D.39079>;
      <D.39078>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.39080>; else goto <D.39081>;
      <D.39080>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39082>; else goto <D.39083>;
      <D.39082>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39083>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39081>:
      D.39084 = mini_get_debug_options ();
      D.39085 = D.39084->break_on_unverified;
      if (D.39085 != 0) goto <D.39086>; else goto unverified;
      <D.39086>:
      raise (5);
      <D.39079>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 442;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      ins->data.op[0].target_block = end_bblock;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      if (D.30577 != 0B) goto <D.39087>; else goto <D.39088>;
      <D.39087>:
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      D.30577->next = ins;
      bblock.64 = bblock;
      D.30577 = bblock.64->last_ins;
      ins->prev = D.30577;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      goto <D.39089>;
      <D.39088>:
      bblock.64 = bblock;
      bblock.64 = bblock;
      bblock.64->last_ins = ins;
      D.30577 = bblock.64->last_ins;
      bblock.64->code = D.30577;
      <D.39089>:
      bblock.64 = bblock;
      link_bblock (cfg, bblock.64, end_bblock);
      start_new_bblock = 1;
      ip = ip + 6;
      goto <D.28026>;
      <D.28053>:
      <D.28054>:
      {
        int token;

        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        if (D.31013 <= 7) goto <D.39090>; else goto <D.39091>;
        <D.39090>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.39092>; else goto <D.39093>;
        <D.39092>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.39094>; else goto <D.39095>;
        <D.39094>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.39095>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.39093>:
        D.39096 = mini_get_debug_options ();
        D.39097 = D.39096->break_on_unverified;
        if (D.39097 != 0) goto <D.39098>; else goto unverified;
        <D.39098>:
        raise (5);
        <D.39091>:
        sp = sp + 18446744073709551608;
        D.34754 = ip + 6;
        if (D.34754 > end) goto <D.39099>; else goto <D.39100>;
        <D.39099>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.39101>; else goto <D.39102>;
        <D.39101>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.39103>; else goto <D.39104>;
        <D.39103>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.39104>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.39102>:
        D.39105 = mini_get_debug_options ();
        D.39106 = D.39105->break_on_unverified;
        if (D.39106 != 0) goto <D.39107>; else goto unverified;
        <D.39107>:
        raise (5);
        <D.39100>:
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38573 = D.38572 << 24;
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38574 = D.38572 >> 8;
        D.38575 = D.38574 & 65280;
        D.38576 = D.38573 | D.38575;
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38577 = D.38572 << 8;
        D.38578 = D.38577 & 16711680;
        D.38579 = D.38576 | D.38578;
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38580 = D.38572 >> 24;
        D.39108 = D.38579 | D.38580;
        token = (int) D.39108;
        token.290 = (unsigned int) token;
        klass.291 = mono_method_get_wrapper_data (method, token.290);
        klass = klass.291;
        D.31270 = ip + 1;
        D.31271 = *D.31270;
        if (D.31271 == 7) goto <D.39111>; else goto <D.39112>;
        <D.39111>:
        klass.144 = klass;
        D.31240 = *sp;
        ins = handle_cisinst (cfg, klass.144, D.31240);
        goto <D.39113>;
        <D.39112>:
        klass.144 = klass;
        D.31240 = *sp;
        ins = handle_ccastclass (cfg, klass.144, D.31240);
        <D.39113>:
        bblock.106 = cfg->cbb;
        bblock = bblock.106;
        sp.292 = sp;
        sp = sp.292 + 8;
        *sp.292 = ins;
        ip = ip + 6;
        goto <D.28026>;
      }
      <D.28056>:
      <D.28057>:
      ip = ip + 2;
      goto <D.28026>;
      <D.28058>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.30924 = header->max_stack;
      D.31146 = (long int) D.30924;
      if (D.31014 >= D.31146) goto <D.39115>; else goto <D.39116>;
      <D.39115>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.39117>; else goto <D.39118>;
      <D.39117>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39119>; else goto <D.39120>;
      <D.39119>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39120>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39118>:
      D.39121 = mini_get_debug_options ();
      D.39122 = D.39121->break_on_unverified;
      if (D.39122 != 0) goto <D.39123>; else goto unverified;
      <D.39123>:
      raise (5);
      <D.39116>:
      D.34754 = ip + 6;
      if (D.34754 > end) goto <D.39124>; else goto <D.39125>;
      <D.39124>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.39126>; else goto <D.39127>;
      <D.39126>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39128>; else goto <D.39129>;
      <D.39128>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39129>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39127>:
      D.39130 = mini_get_debug_options ();
      D.39131 = D.39130->break_on_unverified;
      if (D.39131 != 0) goto <D.39132>; else goto unverified;
      <D.39132>:
      raise (5);
      <D.39125>:
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38573 = D.38572 << 24;
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38574 = D.38572 >> 8;
      D.38575 = D.38574 & 65280;
      D.38576 = D.38573 | D.38575;
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38577 = D.38572 << 8;
      D.38578 = D.38577 & 16711680;
      D.38579 = D.38576 | D.38578;
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38580 = D.38572 >> 24;
      token = D.38579 | D.38580;
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.30635 = D.30634 & 33554432;
      if (D.30635 != 0) goto <D.39134>; else goto <D.39135>;
      <D.39134>:
      iftmp.293 = 732;
      goto <D.39136>;
      <D.39135>:
      iftmp.293 = 363;
      <D.39136>:
      ins->opcode = iftmp.293;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.39137 = mono_method_get_wrapper_data (method, token);
      ins->data.op[0].p = D.39137;
      ins->data.op[1].src = 11B;
      ins->type = 3;
      D.39138 = alloc_dreg (cfg, 3);
      D.39139 = (int) D.39138;
      ins->dreg = D.39139;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.39140>; else goto <D.39141>;
      <D.39140>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.39142>;
      <D.39141>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.39142>:
      sp.294 = sp;
      sp = sp.294 + 8;
      *sp.294 = ins;
      ip = ip + 6;
      num_calls.295 = num_calls;
      num_calls = num_calls.295 + 1;
      D.39145 = num_calls.295 * 10;
      inline_costs = D.39145 + inline_costs;
      goto <D.28026>;
      <D.28059>:
      bblock.64 = bblock;
      bblock.64->out_of_line = 1;
      ip = ip + 2;
      goto <D.28026>;
      <D.28060>:
      {
        int key;

        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        D.31014 = D.31013 /[ex] 8;
        D.30924 = header->max_stack;
        D.31146 = (long int) D.30924;
        if (D.31014 >= D.31146) goto <D.39146>; else goto <D.39147>;
        <D.39146>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.39148>; else goto <D.39149>;
        <D.39148>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.39150>; else goto <D.39151>;
        <D.39150>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.39151>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.39149>:
        D.39152 = mini_get_debug_options ();
        D.39153 = D.39152->break_on_unverified;
        if (D.39153 != 0) goto <D.39154>; else goto unverified;
        <D.39154>:
        raise (5);
        <D.39147>:
        D.34754 = ip + 6;
        if (D.34754 > end) goto <D.39155>; else goto <D.39156>;
        <D.39155>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.39157>; else goto <D.39158>;
        <D.39157>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.39159>; else goto <D.39160>;
        <D.39159>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.39160>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.39158>:
        D.39161 = mini_get_debug_options ();
        D.39162 = D.39161->break_on_unverified;
        if (D.39162 != 0) goto <D.39163>; else goto unverified;
        <D.39163>:
        raise (5);
        <D.39156>:
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38573 = D.38572 << 24;
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38574 = D.38572 >> 8;
        D.38575 = D.38574 & 65280;
        D.38576 = D.38573 | D.38575;
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38577 = D.38572 << 8;
        D.38578 = D.38577 & 16711680;
        D.38579 = D.38576 | D.38578;
        D.31251 = ip + 2;
        D.38572 = MEM[(const guint32 *)D.31251];
        D.38580 = D.38572 >> 24;
        D.39108 = D.38579 | D.38580;
        key = (int) D.39108;
        D.39164 = key > 8;
        D.39165 = (long int) D.39164;
        D.39166 = __builtin_expect (D.39165, 0);
        if (D.39166 != 0) goto <D.39167>; else goto <D.39168>;
        <D.39167>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11268, "key < TLS_KEY_NUM");
        <D.39168>:
        key.296 = (<unnamed type>) key;
        ins = mono_create_tls_get (cfg, key.296);
        if (ins == 0B) goto <D.39170>; else goto <D.39171>;
        <D.39170>:
        D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.30635 = D.30634 & 33554432;
        if (D.30635 != 0) goto <D.39172>; else goto <D.39173>;
        <D.39172>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 1) goto <D.39174>; else goto <D.39175>;
        <D.39174>:
        printf ("AOT disabled: %s:%d\n", "method-to-ir.c", 11273);
        <D.39175>:
        cfg->disable_aot = 1;
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 791;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        D.39176 = alloc_preg (cfg);
        D.39177 = (int) D.39176;
        ins->dreg = D.39177;
        ins->type = 3;
        goto <D.39178>;
        <D.39173>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 11278);
        <D.39178>:
        <D.39171>:
        ins->type = 3;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        if (D.30577 != 0B) goto <D.39179>; else goto <D.39180>;
        <D.39179>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        D.30577->next = ins;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        ins->prev = D.30577;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        goto <D.39181>;
        <D.39180>:
        bblock.64 = bblock;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        D.30577 = bblock.64->last_ins;
        bblock.64->code = D.30577;
        <D.39181>:
        sp.297 = sp;
        sp = sp.297 + 8;
        *sp.297 = ins;
        ip = ip + 6;
        goto <D.28026>;
      }
      <D.28062>:
      {
        struct MonoCallInst * call;

        D.39183 = cfg->dyn_call_var;
        if (D.39183 == 0B) goto <D.39184>; else goto <D.39185>;
        <D.39184>:
        D.30646 = mono_defaults.int_class;
        D.30647 = &D.30646->byval_arg;
        D.39186 = mono_compile_create_var (cfg, D.30647, 329);
        cfg->dyn_call_var = D.39186;
        D.39183 = cfg->dyn_call_var;
        D.39183 = cfg->dyn_call_var;
        D.39187 = D.39183->flags;
        D.39188 = D.39187 | 4;
        D.39183->flags = D.39188;
        <D.39185>:
        D.30241 = cfg->mempool;
        call = mono_mempool_alloc0 (D.30241, 192);
        call->inst.opcode = 361;
        call->inst.dreg = -1;
        call->inst.sreg3 = -1;
        D.39189 = call->inst.sreg3;
        call->inst.sreg2 = D.39189;
        D.39190 = call->inst.sreg2;
        call->inst.sreg1 = D.39190;
        D.30461 = cfg->ip;
        call->inst.cil_code = D.30461;
        ins = call;
        sp = sp + 18446744073709551600;
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        ins->sreg1 = D.31422;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        D.32380 = D.32379->dreg;
        ins->sreg2 = D.32380;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        if (D.30577 != 0B) goto <D.39191>; else goto <D.39192>;
        <D.39191>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        D.30577->next = ins;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        ins->prev = D.30577;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        goto <D.39193>;
        <D.39192>:
        bblock.64 = bblock;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        D.30577 = bblock.64->last_ins;
        bblock.64->code = D.30577;
        <D.39193>:
        D.39194 = cfg->param_area;
        cfg->param_area = D.39194;
        ip = ip + 2;
        num_calls.298 = num_calls;
        num_calls = num_calls.298 + 1;
        D.39196 = num_calls.298 * 10;
        inline_costs = D.39196 + inline_costs;
        goto <D.28026>;
      }
      <D.28064>:
      D.31664 = ip + 5;
      if (D.31664 > end) goto <D.39197>; else goto <D.39198>;
      <D.39197>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.39199>; else goto <D.39200>;
      <D.39199>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39201>; else goto <D.39202>;
      <D.39201>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39202>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39200>:
      D.39203 = mini_get_debug_options ();
      D.39204 = D.39203->break_on_unverified;
      if (D.39204 != 0) goto <D.39205>; else goto unverified;
      <D.39205>:
      raise (5);
      <D.39198>:
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31684 = D.31683 << 24;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31685 = D.31683 >> 8;
      D.31686 = D.31685 & 65280;
      D.31687 = D.31684 | D.31686;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31688 = D.31683 << 8;
      D.31689 = D.31688 & 16711680;
      D.31690 = D.31687 | D.31689;
      D.31270 = ip + 1;
      D.31683 = MEM[(const guint32 *)D.31270];
      D.31691 = D.31683 >> 24;
      D.31692 = D.31690 | D.31691;
      D.31693 = (int) D.31692;
      emit_memory_barrier (cfg, D.31693);
      ip = ip + 5;
      goto <D.28026>;
      <D.28065>:
      {
        struct MonoInst * args[16];
        struct MonoInst * ad_ins;
        struct MonoInst * lmf_ins;
        struct MonoBasicBlock * next_bb;

        try
          {
            next_bb = 0B;
            D.30646 = mono_defaults.int_class;
            D.30647 = &D.30646->byval_arg;
            D.39206 = mono_compile_create_var (cfg, D.30647, 329);
            cfg->orig_domain_var = D.39206;
            D.30241 = cfg->mempool;
            ins = mono_mempool_alloc (D.30241, 80);
            ins->data.op[1].const_val = 0;
            D.30457 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.30457;
            ins->prev = 0B;
            D.30458 = ins->prev;
            ins->next = D.30458;
            ins->opcode = 363;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.30459 = ins->sreg3;
            ins->sreg2 = D.30459;
            D.30460 = ins->sreg2;
            ins->sreg1 = D.30460;
            D.30461 = cfg->ip;
            ins->cil_code = D.30461;
            ins->data.op[0].p = 0B;
            ins->type = 3;
            D.39207 = alloc_dreg (cfg, 3);
            D.39208 = (int) D.39207;
            ins->dreg = D.39208;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.39209>; else goto <D.39210>;
            <D.39209>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = ins;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            ins->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            goto <D.39211>;
            <D.39210>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.39211>:
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.39212 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.39212;
              inst->prev = 0B;
              D.39213 = inst->prev;
              inst->next = D.39213;
              inst->opcode = 424;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.39214 = inst->sreg3;
              inst->sreg2 = D.39214;
              D.39215 = inst->sreg2;
              inst->sreg1 = D.39215;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              D.39216 = cfg->orig_domain_var;
              D.39217 = D.39216->dreg;
              inst->dreg = D.39217;
              D.30654 = ins->dreg;
              inst->sreg1 = D.30654;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.39218>; else goto <D.39219>;
              <D.39218>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.39220>;
              <D.39219>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.39220>:
            }
            ad_ins = mono_get_domain_intrinsic (cfg);
            lmf_ins = mono_get_lmf_intrinsic (cfg);
            if (ad_ins != 0B) goto <D.39221>; else goto <D.39222>;
            <D.39221>:
            if (lmf_ins != 0B) goto <D.39223>; else goto <D.39224>;
            <D.39223>:
            D.30241 = cfg->mempool;
            next_bb = mono_mempool_alloc0 (D.30241, 296);
            D.30349 = cfg->num_bblocks;
            D.39225 = D.30349;
            D.39226 = D.39225 + 1;
            cfg->num_bblocks = D.39226;
            D.39227 = (int) D.39225;
            next_bb->block_num = D.39227;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.39228>; else goto <D.39229>;
            <D.39228>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = ad_ins;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            ad_ins->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ad_ins;
            goto <D.39230>;
            <D.39229>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ad_ins;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.39230>:
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.39231 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.39231;
              inst->prev = 0B;
              D.39232 = inst->prev;
              inst->next = D.39232;
              inst->opcode = 323;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.39233 = inst->sreg3;
              inst->sreg2 = D.39233;
              D.39234 = inst->sreg2;
              inst->sreg1 = D.39234;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = -1;
              D.39235 = ad_ins->dreg;
              inst->sreg1 = D.39235;
              inst->data.op[1].const_val = 0;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.39236>; else goto <D.39237>;
              <D.39236>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.39238>;
              <D.39237>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.39238>:
            }
            {
              struct MonoInst * ins;
              struct MonoBasicBlock * falsebb;

              D.30241 = cfg->mempool;
              ins = mono_mempool_alloc (D.30241, 80);
              ins->data.op[1].const_val = 0;
              D.39239 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.39239;
              ins->prev = 0B;
              D.39240 = ins->prev;
              ins->next = D.39240;
              ins->opcode = 556;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.39241 = ins->sreg3;
              ins->sreg2 = D.39241;
              D.39242 = ins->sreg2;
              ins->sreg1 = D.39242;
              D.30461 = cfg->ip;
              ins->cil_code = D.30461;
              if (0 != 0) goto <D.39243>; else goto <D.39244>;
              <D.39243>:
              D.30241 = cfg->mempool;
              falsebb = mono_mempool_alloc0 (D.30241, 296);
              D.30349 = cfg->num_bblocks;
              D.39245 = D.30349;
              D.39246 = D.39245 + 1;
              cfg->num_bblocks = D.39246;
              D.39247 = (int) D.39245;
              falsebb->block_num = D.39247;
              ins->data.op[0].target_block = next_bb;
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, next_bb);
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.39248>; else goto <D.39249>;
              <D.39248>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = ins;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              ins->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              goto <D.39250>;
              <D.39249>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.39250>:
              D.39251 = falsebb->cil_code;
              if (D.39251 != 0B) goto <D.39252>; else goto <D.39253>;
              <D.39252>:
              D.30372 = cfg->cil_offset_to_bb;
              D.39251 = falsebb->cil_code;
              D.39254 = (long int) D.39251;
              D.30377 = cfg->cil_start;
              D.30378 = (long int) D.30377;
              D.39255 = D.39254 - D.30378;
              D.39256 = (long unsigned int) D.39255;
              D.39257 = D.39256 * 8;
              D.39258 = D.30372 + D.39257;
              *D.39258 = falsebb;
              <D.39253>:
              D.30408 = cfg->real_offset;
              falsebb->real_offset = D.30408;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.39262>; else goto <D.39259>;
              <D.39262>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34178 = D.34177 + 64985;
              if (D.34178 <= 9) goto <D.39260>; else goto <D.39263>;
              <D.39263>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34180 = D.34177 + 64878;
              if (D.34180 <= 9) goto <D.39260>; else goto <D.39264>;
              <D.39264>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34182 = D.34177 + 64888;
              if (D.34182 <= 9) goto <D.39260>; else goto <D.39259>;
              <D.39260>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34183 = D.30490->data.op[1].many_blocks;
              D.34184 = D.34183 + 8;
              D.34185 = *D.34184;
              if (D.34185 == 0B) goto <D.39265>; else goto <D.39259>;
              <D.39265>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34183 = D.30490->data.op[1].many_blocks;
              D.34184 = D.34183 + 8;
              *D.34184 = falsebb;
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, falsebb);
              goto <D.39261>;
              <D.39259>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 == 0B) goto <D.39266>; else goto <D.39268>;
              <D.39268>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              if (D.34177 != 442) goto <D.39269>; else goto <D.39267>;
              <D.39269>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              if (D.34177 != 759) goto <D.39270>; else goto <D.39267>;
              <D.39270>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34178 = D.34177 + 64985;
              if (D.34178 > 9) goto <D.39271>; else goto <D.39267>;
              <D.39271>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34180 = D.34177 + 64878;
              if (D.34180 > 9) goto <D.39272>; else goto <D.39267>;
              <D.39272>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34182 = D.34177 + 64888;
              if (D.34182 > 9) goto <D.39266>; else goto <D.39267>;
              <D.39266>:
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, falsebb);
              <D.39267>:
              <D.39261>:
              bblock.106 = cfg->cbb;
              bblock.106->next_bb = falsebb;
              cfg->cbb = falsebb;
              goto <D.39273>;
              <D.39244>:
              D.30241 = cfg->mempool;
              D.39274 = mono_mempool_alloc (D.30241, 16);
              ins->data.op[1].many_blocks = D.39274;
              D.39275 = ins->data.op[1].many_blocks;
              *D.39275 = next_bb;
              D.39275 = ins->data.op[1].many_blocks;
              D.39276 = D.39275 + 8;
              *D.39276 = 0B;
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, next_bb);
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.39277>; else goto <D.39278>;
              <D.39277>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = ins;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              ins->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              goto <D.39279>;
              <D.39278>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.39279>:
              D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.34201 = D.30634 & 268435456;
              if (D.34201 == 0) goto <D.39280>; else goto <D.39281>;
              <D.39280>:
              D.30241 = cfg->mempool;
              falsebb = mono_mempool_alloc0 (D.30241, 296);
              D.30349 = cfg->num_bblocks;
              D.39282 = D.30349;
              D.39283 = D.39282 + 1;
              cfg->num_bblocks = D.39283;
              D.39284 = (int) D.39282;
              falsebb->block_num = D.39284;
              D.39275 = ins->data.op[1].many_blocks;
              D.39276 = D.39275 + 8;
              *D.39276 = falsebb;
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, falsebb);
              D.39251 = falsebb->cil_code;
              if (D.39251 != 0B) goto <D.39285>; else goto <D.39286>;
              <D.39285>:
              D.30372 = cfg->cil_offset_to_bb;
              D.39251 = falsebb->cil_code;
              D.39254 = (long int) D.39251;
              D.30377 = cfg->cil_start;
              D.30378 = (long int) D.30377;
              D.39255 = D.39254 - D.30378;
              D.39256 = (long unsigned int) D.39255;
              D.39257 = D.39256 * 8;
              D.39258 = D.30372 + D.39257;
              *D.39258 = falsebb;
              <D.39286>:
              D.30408 = cfg->real_offset;
              falsebb->real_offset = D.30408;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.39290>; else goto <D.39287>;
              <D.39290>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34178 = D.34177 + 64985;
              if (D.34178 <= 9) goto <D.39288>; else goto <D.39291>;
              <D.39291>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34180 = D.34177 + 64878;
              if (D.34180 <= 9) goto <D.39288>; else goto <D.39292>;
              <D.39292>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34182 = D.34177 + 64888;
              if (D.34182 <= 9) goto <D.39288>; else goto <D.39287>;
              <D.39288>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34183 = D.30490->data.op[1].many_blocks;
              D.34184 = D.34183 + 8;
              D.34185 = *D.34184;
              if (D.34185 == 0B) goto <D.39293>; else goto <D.39287>;
              <D.39293>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34183 = D.30490->data.op[1].many_blocks;
              D.34184 = D.34183 + 8;
              *D.34184 = falsebb;
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, falsebb);
              goto <D.39289>;
              <D.39287>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 == 0B) goto <D.39294>; else goto <D.39296>;
              <D.39296>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              if (D.34177 != 442) goto <D.39297>; else goto <D.39295>;
              <D.39297>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              if (D.34177 != 759) goto <D.39298>; else goto <D.39295>;
              <D.39298>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34178 = D.34177 + 64985;
              if (D.34178 > 9) goto <D.39299>; else goto <D.39295>;
              <D.39299>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34180 = D.34177 + 64878;
              if (D.34180 > 9) goto <D.39300>; else goto <D.39295>;
              <D.39300>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34182 = D.34177 + 64888;
              if (D.34182 > 9) goto <D.39294>; else goto <D.39295>;
              <D.39294>:
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, falsebb);
              <D.39295>:
              <D.39289>:
              bblock.106 = cfg->cbb;
              bblock.106->next_bb = falsebb;
              cfg->cbb = falsebb;
              goto <D.39301>;
              <D.39281>:
              bblock.106 = cfg->cbb;
              bblock.106->extended = 1;
              <D.39301>:
              <D.39273>:
            }
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.39302>; else goto <D.39303>;
            <D.39302>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = lmf_ins;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            lmf_ins->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = lmf_ins;
            goto <D.39304>;
            <D.39303>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = lmf_ins;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.39304>:
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.39305 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.39305;
              inst->prev = 0B;
              D.39306 = inst->prev;
              inst->next = D.39306;
              inst->opcode = 323;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.39307 = inst->sreg3;
              inst->sreg2 = D.39307;
              D.39308 = inst->sreg2;
              inst->sreg1 = D.39308;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              inst->dreg = -1;
              D.39309 = lmf_ins->dreg;
              inst->sreg1 = D.39309;
              inst->data.op[1].const_val = 0;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.39310>; else goto <D.39311>;
              <D.39310>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.39312>;
              <D.39311>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.39312>:
            }
            {
              struct MonoInst * ins;
              struct MonoBasicBlock * falsebb;

              D.30241 = cfg->mempool;
              ins = mono_mempool_alloc (D.30241, 80);
              ins->data.op[1].const_val = 0;
              D.39313 = ins->data.op[1].const_val;
              ins->data.op[0].const_val = D.39313;
              ins->prev = 0B;
              D.39314 = ins->prev;
              ins->next = D.39314;
              ins->opcode = 556;
              ins->flags = 0;
              ins->type = 0;
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.39315 = ins->sreg3;
              ins->sreg2 = D.39315;
              D.39316 = ins->sreg2;
              ins->sreg1 = D.39316;
              D.30461 = cfg->ip;
              ins->cil_code = D.30461;
              if (0 != 0) goto <D.39317>; else goto <D.39318>;
              <D.39317>:
              D.30241 = cfg->mempool;
              falsebb = mono_mempool_alloc0 (D.30241, 296);
              D.30349 = cfg->num_bblocks;
              D.39319 = D.30349;
              D.39320 = D.39319 + 1;
              cfg->num_bblocks = D.39320;
              D.39321 = (int) D.39319;
              falsebb->block_num = D.39321;
              ins->data.op[0].target_block = next_bb;
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, next_bb);
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.39322>; else goto <D.39323>;
              <D.39322>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = ins;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              ins->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              goto <D.39324>;
              <D.39323>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.39324>:
              D.39325 = falsebb->cil_code;
              if (D.39325 != 0B) goto <D.39326>; else goto <D.39327>;
              <D.39326>:
              D.30372 = cfg->cil_offset_to_bb;
              D.39325 = falsebb->cil_code;
              D.39328 = (long int) D.39325;
              D.30377 = cfg->cil_start;
              D.30378 = (long int) D.30377;
              D.39329 = D.39328 - D.30378;
              D.39330 = (long unsigned int) D.39329;
              D.39331 = D.39330 * 8;
              D.39332 = D.30372 + D.39331;
              *D.39332 = falsebb;
              <D.39327>:
              D.30408 = cfg->real_offset;
              falsebb->real_offset = D.30408;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.39336>; else goto <D.39333>;
              <D.39336>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34178 = D.34177 + 64985;
              if (D.34178 <= 9) goto <D.39334>; else goto <D.39337>;
              <D.39337>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34180 = D.34177 + 64878;
              if (D.34180 <= 9) goto <D.39334>; else goto <D.39338>;
              <D.39338>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34182 = D.34177 + 64888;
              if (D.34182 <= 9) goto <D.39334>; else goto <D.39333>;
              <D.39334>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34183 = D.30490->data.op[1].many_blocks;
              D.34184 = D.34183 + 8;
              D.34185 = *D.34184;
              if (D.34185 == 0B) goto <D.39339>; else goto <D.39333>;
              <D.39339>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34183 = D.30490->data.op[1].many_blocks;
              D.34184 = D.34183 + 8;
              *D.34184 = falsebb;
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, falsebb);
              goto <D.39335>;
              <D.39333>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 == 0B) goto <D.39340>; else goto <D.39342>;
              <D.39342>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              if (D.34177 != 442) goto <D.39343>; else goto <D.39341>;
              <D.39343>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              if (D.34177 != 759) goto <D.39344>; else goto <D.39341>;
              <D.39344>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34178 = D.34177 + 64985;
              if (D.34178 > 9) goto <D.39345>; else goto <D.39341>;
              <D.39345>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34180 = D.34177 + 64878;
              if (D.34180 > 9) goto <D.39346>; else goto <D.39341>;
              <D.39346>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34182 = D.34177 + 64888;
              if (D.34182 > 9) goto <D.39340>; else goto <D.39341>;
              <D.39340>:
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, falsebb);
              <D.39341>:
              <D.39335>:
              bblock.106 = cfg->cbb;
              bblock.106->next_bb = falsebb;
              cfg->cbb = falsebb;
              goto <D.39347>;
              <D.39318>:
              D.30241 = cfg->mempool;
              D.39348 = mono_mempool_alloc (D.30241, 16);
              ins->data.op[1].many_blocks = D.39348;
              D.39349 = ins->data.op[1].many_blocks;
              *D.39349 = next_bb;
              D.39349 = ins->data.op[1].many_blocks;
              D.39350 = D.39349 + 8;
              *D.39350 = 0B;
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, next_bb);
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.39351>; else goto <D.39352>;
              <D.39351>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = ins;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              ins->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              goto <D.39353>;
              <D.39352>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = ins;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.39353>:
              D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.34201 = D.30634 & 268435456;
              if (D.34201 == 0) goto <D.39354>; else goto <D.39355>;
              <D.39354>:
              D.30241 = cfg->mempool;
              falsebb = mono_mempool_alloc0 (D.30241, 296);
              D.30349 = cfg->num_bblocks;
              D.39356 = D.30349;
              D.39357 = D.39356 + 1;
              cfg->num_bblocks = D.39357;
              D.39358 = (int) D.39356;
              falsebb->block_num = D.39358;
              D.39349 = ins->data.op[1].many_blocks;
              D.39350 = D.39349 + 8;
              *D.39350 = falsebb;
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, falsebb);
              D.39325 = falsebb->cil_code;
              if (D.39325 != 0B) goto <D.39359>; else goto <D.39360>;
              <D.39359>:
              D.30372 = cfg->cil_offset_to_bb;
              D.39325 = falsebb->cil_code;
              D.39328 = (long int) D.39325;
              D.30377 = cfg->cil_start;
              D.30378 = (long int) D.30377;
              D.39329 = D.39328 - D.30378;
              D.39330 = (long unsigned int) D.39329;
              D.39331 = D.39330 * 8;
              D.39332 = D.30372 + D.39331;
              *D.39332 = falsebb;
              <D.39360>:
              D.30408 = cfg->real_offset;
              falsebb->real_offset = D.30408;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.39364>; else goto <D.39361>;
              <D.39364>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34178 = D.34177 + 64985;
              if (D.34178 <= 9) goto <D.39362>; else goto <D.39365>;
              <D.39365>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34180 = D.34177 + 64878;
              if (D.34180 <= 9) goto <D.39362>; else goto <D.39366>;
              <D.39366>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34182 = D.34177 + 64888;
              if (D.34182 <= 9) goto <D.39362>; else goto <D.39361>;
              <D.39362>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34183 = D.30490->data.op[1].many_blocks;
              D.34184 = D.34183 + 8;
              D.34185 = *D.34184;
              if (D.34185 == 0B) goto <D.39367>; else goto <D.39361>;
              <D.39367>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34183 = D.30490->data.op[1].many_blocks;
              D.34184 = D.34183 + 8;
              *D.34184 = falsebb;
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, falsebb);
              goto <D.39363>;
              <D.39361>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 == 0B) goto <D.39368>; else goto <D.39370>;
              <D.39370>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              if (D.34177 != 442) goto <D.39371>; else goto <D.39369>;
              <D.39371>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              if (D.34177 != 759) goto <D.39372>; else goto <D.39369>;
              <D.39372>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34178 = D.34177 + 64985;
              if (D.34178 > 9) goto <D.39373>; else goto <D.39369>;
              <D.39373>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34180 = D.34177 + 64878;
              if (D.34180 > 9) goto <D.39374>; else goto <D.39369>;
              <D.39374>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.34177 = D.30490->opcode;
              D.34182 = D.34177 + 64888;
              if (D.34182 > 9) goto <D.39368>; else goto <D.39369>;
              <D.39368>:
              bblock.106 = cfg->cbb;
              mono_link_bblock (cfg, bblock.106, falsebb);
              <D.39369>:
              <D.39363>:
              bblock.106 = cfg->cbb;
              bblock.106->next_bb = falsebb;
              cfg->cbb = falsebb;
              goto <D.39375>;
              <D.39355>:
              bblock.106 = cfg->cbb;
              bblock.106->extended = 1;
              <D.39375>:
              <D.39347>:
            }
            <D.39224>:
            <D.39222>:
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.30635 = D.30634 & 33554432;
            if (D.30635 != 0) goto <D.39376>; else goto <D.39377>;
            <D.39376>:
            D.30241 = cfg->mempool;
            D.39378 = mono_mempool_alloc (D.30241, 80);
            args[0] = D.39378;
            D.39379 = args[0];
            D.39379 = args[0];
            D.39379->data.op[1].const_val = 0;
            D.39380 = D.39379->data.op[1].const_val;
            D.39379->data.op[0].const_val = D.39380;
            D.39379 = args[0];
            D.39379 = args[0];
            D.39379->prev = 0B;
            D.39381 = D.39379->prev;
            D.39379->next = D.39381;
            D.39379 = args[0];
            D.39379->opcode = 363;
            D.39379 = args[0];
            D.39379->flags = 0;
            D.39379 = args[0];
            D.39379->type = 0;
            D.39379 = args[0];
            D.39379->dreg = -1;
            D.39379 = args[0];
            D.39379 = args[0];
            D.39379 = args[0];
            D.39379->sreg3 = -1;
            D.39382 = D.39379->sreg3;
            D.39379->sreg2 = D.39382;
            D.39383 = D.39379->sreg2;
            D.39379->sreg1 = D.39383;
            D.39379 = args[0];
            D.30461 = cfg->ip;
            D.39379->cil_code = D.30461;
            D.39379 = args[0];
            D.39379->data.op[0].p = 0B;
            D.39379 = args[0];
            D.39379->type = 3;
            D.39379 = args[0];
            D.39384 = alloc_dreg (cfg, 3);
            D.39385 = (int) D.39384;
            D.39379->dreg = D.39385;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.39386>; else goto <D.39387>;
            <D.39386>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.39379 = args[0];
            D.30490->next = D.39379;
            D.39379 = args[0];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.39379->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.39379 = args[0];
            bblock.106->last_ins = D.39379;
            goto <D.39388>;
            <D.39387>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.39379 = args[0];
            bblock.106->last_ins = D.39379;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.39388>:
            goto <D.39389>;
            <D.39377>:
            D.30241 = cfg->mempool;
            D.39390 = mono_mempool_alloc (D.30241, 80);
            args[0] = D.39390;
            D.39379 = args[0];
            D.39379 = args[0];
            D.39379->data.op[1].const_val = 0;
            D.39380 = D.39379->data.op[1].const_val;
            D.39379->data.op[0].const_val = D.39380;
            D.39379 = args[0];
            D.39379 = args[0];
            D.39379->prev = 0B;
            D.39381 = D.39379->prev;
            D.39379->next = D.39381;
            D.39379 = args[0];
            D.39379->opcode = 363;
            D.39379 = args[0];
            D.39379->flags = 0;
            D.39379 = args[0];
            D.39379->type = 0;
            D.39379 = args[0];
            D.39379->dreg = -1;
            D.39379 = args[0];
            D.39379 = args[0];
            D.39379 = args[0];
            D.39379->sreg3 = -1;
            D.39382 = D.39379->sreg3;
            D.39379->sreg2 = D.39382;
            D.39383 = D.39379->sreg2;
            D.39379->sreg1 = D.39383;
            D.39379 = args[0];
            D.30461 = cfg->ip;
            D.39379->cil_code = D.30461;
            D.39379 = args[0];
            D.30267 = cfg->domain;
            D.39379->data.op[0].p = D.30267;
            D.39379 = args[0];
            D.39379->type = 3;
            D.39379 = args[0];
            D.39391 = alloc_dreg (cfg, 3);
            D.39392 = (int) D.39391;
            D.39379->dreg = D.39392;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.39393>; else goto <D.39394>;
            <D.39393>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.39379 = args[0];
            D.30490->next = D.39379;
            D.39379 = args[0];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.39379->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.39379 = args[0];
            bblock.106->last_ins = D.39379;
            goto <D.39395>;
            <D.39394>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.39379 = args[0];
            bblock.106->last_ins = D.39379;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.39395>:
            <D.39389>:
            ins = mono_emit_jit_icall (cfg, mono_jit_thread_attach, &args);
            {
              struct MonoInst * inst;

              D.30241 = cfg->mempool;
              inst = mono_mempool_alloc (D.30241, 80);
              inst->data.op[1].const_val = 0;
              D.39396 = inst->data.op[1].const_val;
              inst->data.op[0].const_val = D.39396;
              inst->prev = 0B;
              D.39397 = inst->prev;
              inst->next = D.39397;
              inst->opcode = 424;
              inst->flags = 0;
              inst->type = 0;
              inst->dreg = -1;
              inst->sreg3 = -1;
              D.39398 = inst->sreg3;
              inst->sreg2 = D.39398;
              D.39399 = inst->sreg2;
              inst->sreg1 = D.39399;
              D.30461 = cfg->ip;
              inst->cil_code = D.30461;
              D.39216 = cfg->orig_domain_var;
              D.39217 = D.39216->dreg;
              inst->dreg = D.39217;
              D.30654 = ins->dreg;
              inst->sreg1 = D.30654;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              if (D.30490 != 0B) goto <D.39400>; else goto <D.39401>;
              <D.39400>:
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              D.30490->next = inst;
              bblock.106 = cfg->cbb;
              D.30490 = bblock.106->last_ins;
              inst->prev = D.30490;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              goto <D.39402>;
              <D.39401>:
              bblock.106 = cfg->cbb;
              bblock.106 = cfg->cbb;
              bblock.106->last_ins = inst;
              D.30490 = bblock.106->last_ins;
              bblock.106->code = D.30490;
              <D.39402>:
            }
            if (next_bb != 0B) goto <D.39403>; else goto <D.39404>;
            <D.39403>:
            D.39405 = next_bb->cil_code;
            if (D.39405 != 0B) goto <D.39406>; else goto <D.39407>;
            <D.39406>:
            D.30372 = cfg->cil_offset_to_bb;
            D.39405 = next_bb->cil_code;
            D.39408 = (long int) D.39405;
            D.30377 = cfg->cil_start;
            D.30378 = (long int) D.30377;
            D.39409 = D.39408 - D.30378;
            D.39410 = (long unsigned int) D.39409;
            D.39411 = D.39410 * 8;
            D.39412 = D.30372 + D.39411;
            *D.39412 = next_bb;
            <D.39407>:
            D.30408 = cfg->real_offset;
            next_bb->real_offset = D.30408;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.39416>; else goto <D.39413>;
            <D.39416>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34177 = D.30490->opcode;
            D.34178 = D.34177 + 64985;
            if (D.34178 <= 9) goto <D.39414>; else goto <D.39417>;
            <D.39417>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34177 = D.30490->opcode;
            D.34180 = D.34177 + 64878;
            if (D.34180 <= 9) goto <D.39414>; else goto <D.39418>;
            <D.39418>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34177 = D.30490->opcode;
            D.34182 = D.34177 + 64888;
            if (D.34182 <= 9) goto <D.39414>; else goto <D.39413>;
            <D.39414>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34183 = D.30490->data.op[1].many_blocks;
            D.34184 = D.34183 + 8;
            D.34185 = *D.34184;
            if (D.34185 == 0B) goto <D.39419>; else goto <D.39413>;
            <D.39419>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34183 = D.30490->data.op[1].many_blocks;
            D.34184 = D.34183 + 8;
            *D.34184 = next_bb;
            bblock.106 = cfg->cbb;
            mono_link_bblock (cfg, bblock.106, next_bb);
            goto <D.39415>;
            <D.39413>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 == 0B) goto <D.39420>; else goto <D.39422>;
            <D.39422>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34177 = D.30490->opcode;
            if (D.34177 != 442) goto <D.39423>; else goto <D.39421>;
            <D.39423>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34177 = D.30490->opcode;
            if (D.34177 != 759) goto <D.39424>; else goto <D.39421>;
            <D.39424>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34177 = D.30490->opcode;
            D.34178 = D.34177 + 64985;
            if (D.34178 > 9) goto <D.39425>; else goto <D.39421>;
            <D.39425>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34177 = D.30490->opcode;
            D.34180 = D.34177 + 64878;
            if (D.34180 > 9) goto <D.39426>; else goto <D.39421>;
            <D.39426>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.34177 = D.30490->opcode;
            D.34182 = D.34177 + 64888;
            if (D.34182 > 9) goto <D.39420>; else goto <D.39421>;
            <D.39420>:
            bblock.106 = cfg->cbb;
            mono_link_bblock (cfg, bblock.106, next_bb);
            <D.39421>:
            <D.39415>:
            bblock.106 = cfg->cbb;
            bblock.106->next_bb = next_bb;
            cfg->cbb = next_bb;
            bblock.106 = cfg->cbb;
            bblock = bblock.106;
            <D.39404>:
            ip = ip + 2;
            goto <D.28026>;
          }
        finally
          {
            args = {CLOBBER};
          }
      }
      <D.28078>:
      {
        struct MonoInst * args[16];

        try
          {
            D.39427 = alloc_ireg (cfg);
            dreg = (int) D.39427;
            D.30241 = cfg->mempool;
            D.39428 = mono_mempool_alloc (D.30241, 80);
            args[0] = D.39428;
            D.39429 = args[0];
            D.39429 = args[0];
            D.39429->data.op[1].const_val = 0;
            D.39430 = D.39429->data.op[1].const_val;
            D.39429->data.op[0].const_val = D.39430;
            D.39429 = args[0];
            D.39429 = args[0];
            D.39429->prev = 0B;
            D.39431 = D.39429->prev;
            D.39429->next = D.39431;
            D.39429 = args[0];
            D.39429->opcode = 424;
            D.39429 = args[0];
            D.39429->flags = 0;
            D.39429 = args[0];
            D.39429->type = 0;
            D.39429 = args[0];
            D.39429->dreg = -1;
            D.39429 = args[0];
            D.39429 = args[0];
            D.39429 = args[0];
            D.39429->sreg3 = -1;
            D.39432 = D.39429->sreg3;
            D.39429->sreg2 = D.39432;
            D.39433 = D.39429->sreg2;
            D.39429->sreg1 = D.39433;
            D.39429 = args[0];
            D.30461 = cfg->ip;
            D.39429->cil_code = D.30461;
            D.39429 = args[0];
            D.39429->dreg = dreg;
            D.39429 = args[0];
            D.39216 = cfg->orig_domain_var;
            D.39217 = D.39216->dreg;
            D.39429->sreg1 = D.39217;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.39434>; else goto <D.39435>;
            <D.39434>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.39429 = args[0];
            D.30490->next = D.39429;
            D.39429 = args[0];
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.39429->prev = D.30490;
            bblock.106 = cfg->cbb;
            D.39429 = args[0];
            bblock.106->last_ins = D.39429;
            goto <D.39436>;
            <D.39435>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            D.39429 = args[0];
            bblock.106->last_ins = D.39429;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.39436>:
            mono_emit_jit_icall (cfg, mono_jit_set_domain, &args);
            ip = ip + 2;
            goto <D.28026>;
          }
        finally
          {
            args = {CLOBBER};
          }
      }
      <D.28080>:
      D.31270 = ip + 1;
      D.31271 = *D.31270;
      D.31579 = (int) D.31271;
      monoeg_g_log (0B, 4, "opcode 0x%02x 0x%02x not handled", 240, D.31579);
      <D.28081>:
      goto <D.28081>;
      <D.28026>:
      goto <D.27394>;
      <D.28082>:
      D.31251 = ip + 2;
      if (D.31251 > end) goto <D.39437>; else goto <D.39438>;
      <D.39437>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.39439>; else goto <D.39440>;
      <D.39439>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39441>; else goto <D.39442>;
      <D.39441>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39442>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39440>:
      D.39443 = mini_get_debug_options ();
      D.39444 = D.39443->break_on_unverified;
      if (D.39444 != 0) goto <D.39445>; else goto unverified;
      <D.39445>:
      raise (5);
      <D.39438>:
      D.31270 = ip + 1;
      D.31271 = *D.31270;
      D.31579 = (int) D.31271;
      switch (D.31579) <default: <D.28163>, case 0: <D.28083>, case 1: <D.28089>, case 2: <D.28090>, case 3: <D.28091>, case 4: <D.28092>, case 5: <D.28093>, case 6: <D.28095>, case 7: <D.28106>, case 8: <D.28158>, case 9: <D.28108>, case 10: <D.28109>, case 11: <D.28112>, case 12: <D.28113>, case 13: <D.28114>, case 14: <D.28118>, case 15: <D.28119>, case 16: <D.28159>, case 17: <D.28120>, case 18: <D.28128>, case 19: <D.28129>, case 20: <D.28130>, case 21: <D.28131>, case 22: <D.28133>, case 23: <D.28134>, case 24: <D.28135>, case 25: <D.28139>, case 26: <D.28140>, case 27: <D.28161>, case 28: <D.28147>, case 29: <D.28152>, case 30: <D.28157>, case 34: <D.28160>, case 36: <D.28162>>
      <D.28083>:
      {
        struct MonoInst * addr;
        struct MonoInst * vtvar;

        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        D.31014 = D.31013 /[ex] 8;
        D.30924 = header->max_stack;
        D.31146 = (long int) D.30924;
        if (D.31014 >= D.31146) goto <D.39446>; else goto <D.39447>;
        <D.39446>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.39448>; else goto <D.39449>;
        <D.39448>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.39450>; else goto <D.39451>;
        <D.39450>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.39451>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.39449>:
        D.39452 = mini_get_debug_options ();
        D.39453 = D.39452->break_on_unverified;
        if (D.39453 != 0) goto <D.39454>; else goto unverified;
        <D.39454>:
        raise (5);
        <D.39447>:
        D.39455 = mono_defaults.argumenthandle_class;
        D.39456 = &D.39455->byval_arg;
        vtvar = mono_compile_create_var (cfg, D.39456, 329);
        D.30241 = cfg->mempool;
        addr = mono_mempool_alloc (D.30241, 80);
        addr->data.op[1].const_val = 0;
        D.39457 = addr->data.op[1].const_val;
        addr->data.op[0].const_val = D.39457;
        addr->prev = 0B;
        D.39458 = addr->prev;
        addr->next = D.39458;
        addr->opcode = 314;
        addr->flags = 0;
        addr->type = 0;
        addr->dreg = -1;
        addr->sreg3 = -1;
        D.39459 = addr->sreg3;
        addr->sreg2 = D.39459;
        D.39460 = addr->sreg2;
        addr->sreg1 = D.39460;
        D.30461 = cfg->ip;
        addr->cil_code = D.30461;
        D.30978 = cfg->varinfo;
        D.39461 = vtvar->data.op[0].const_val;
        D.39462 = (long unsigned int) D.39461;
        D.39463 = D.39462 * 8;
        D.39464 = D.30978 + D.39463;
        D.39465 = *D.39464;
        addr->data.op[0].p = D.39465;
        D.30978 = cfg->varinfo;
        D.39461 = vtvar->data.op[0].const_val;
        D.39462 = (long unsigned int) D.39461;
        D.39463 = D.39462 * 8;
        D.39464 = D.30978 + D.39463;
        D.39465 = *D.39464;
        D.30978 = cfg->varinfo;
        D.39461 = vtvar->data.op[0].const_val;
        D.39462 = (long unsigned int) D.39461;
        D.39463 = D.39462 * 8;
        D.39464 = D.30978 + D.39463;
        D.39465 = *D.39464;
        D.39466 = D.39465->flags;
        D.39467 = D.39466 | 16;
        D.39465->flags = D.39467;
        addr->type = 5;
        D.30978 = cfg->varinfo;
        D.39461 = vtvar->data.op[0].const_val;
        D.39462 = (long unsigned int) D.39461;
        D.39463 = D.39462 * 8;
        D.39464 = D.30978 + D.39463;
        D.39465 = *D.39464;
        D.39468 = D.39465->klass;
        addr->klass = D.39468;
        D.39469 = alloc_dreg (cfg, 5);
        D.39470 = (int) D.39469;
        addr->dreg = D.39470;
        cfg->has_indirection = 1;
        D.30389 = cfg->gsharedvt;
        D.31326 = D.30389 != 0;
        D.31327 = (long int) D.31326;
        D.31328 = __builtin_expect (D.31327, 0);
        if (D.31328 != 0) goto <D.39471>; else goto <D.39472>;
        <D.39471>:
        D.30978 = cfg->varinfo;
        D.39461 = vtvar->data.op[0].const_val;
        D.39462 = (long unsigned int) D.39461;
        D.39463 = D.39462 * 8;
        D.39464 = D.30978 + D.39463;
        D.39465 = *D.39464;
        D.39473 = D.39465->data.op[1].vtype;
        D.39474 = mini_is_gsharedvt_variable_type (cfg, D.39473);
        if (D.39474 != 0) goto <D.39475>; else goto <D.39476>;
        <D.39475>:
        handle_gsharedvt_ldaddr (cfg);
        <D.39476>:
        <D.39472>:
        if (0 != 0) goto <D.39477>; else goto <D.39478>;
        <D.39477>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.30978 = cfg->varinfo;
          D.39461 = vtvar->data.op[0].const_val;
          D.39462 = (long unsigned int) D.39461;
          D.39463 = D.39462 * 8;
          D.39464 = D.30978 + D.39463;
          D.39465 = *D.39464;
          D.39480 = D.39465->dreg;
          D.39481 = D.39480 + 1;
          D.39482 = (unsigned int) D.39481;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.39482 < D.31341) goto <D.39483>; else goto <D.39484>;
          <D.39483>:
          D.31344 = cfg->vreg_to_inst;
          D.30978 = cfg->varinfo;
          D.39461 = vtvar->data.op[0].const_val;
          D.39462 = (long unsigned int) D.39461;
          D.39463 = D.39462 * 8;
          D.39464 = D.30978 + D.39463;
          D.39465 = *D.39464;
          D.39480 = D.39465->dreg;
          D.39485 = (sizetype) D.39480;
          D.39486 = D.39485 + 1;
          D.39487 = D.39486 * 8;
          D.39488 = D.31344 + D.39487;
          iftmp.299 = *D.39488;
          goto <D.39489>;
          <D.39484>:
          iftmp.299 = 0B;
          <D.39489>:
          var1 = iftmp.299;
          D.30978 = cfg->varinfo;
          D.39461 = vtvar->data.op[0].const_val;
          D.39462 = (long unsigned int) D.39461;
          D.39463 = D.39462 * 8;
          D.39464 = D.30978 + D.39463;
          D.39465 = *D.39464;
          D.39480 = D.39465->dreg;
          D.39491 = D.39480 + 2;
          D.39492 = (unsigned int) D.39491;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.39492 < D.31341) goto <D.39493>; else goto <D.39494>;
          <D.39493>:
          D.31344 = cfg->vreg_to_inst;
          D.30978 = cfg->varinfo;
          D.39461 = vtvar->data.op[0].const_val;
          D.39462 = (long unsigned int) D.39461;
          D.39463 = D.39462 * 8;
          D.39464 = D.30978 + D.39463;
          D.39465 = *D.39464;
          D.39480 = D.39465->dreg;
          D.39485 = (sizetype) D.39480;
          D.39495 = D.39485 + 2;
          D.39496 = D.39495 * 8;
          D.39497 = D.31344 + D.39496;
          iftmp.300 = *D.39497;
          goto <D.39498>;
          <D.39494>:
          iftmp.300 = 0B;
          <D.39498>:
          var2 = iftmp.300;
          D.39499 = var1 == 0B;
          D.39500 = (long int) D.39499;
          D.39501 = __builtin_expect (D.39500, 0);
          if (D.39501 != 0) goto <D.39502>; else goto <D.39503>;
          <D.39502>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11394, "var1");
          <D.39503>:
          D.39504 = var2 == 0B;
          D.39505 = (long int) D.39504;
          D.39506 = __builtin_expect (D.39505, 0);
          if (D.39506 != 0) goto <D.39507>; else goto <D.39508>;
          <D.39507>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11394, "var2");
          <D.39508>:
          D.39509 = var1->flags;
          D.39510 = D.39509 | 16;
          var1->flags = D.39510;
          D.39511 = var2->flags;
          D.39512 = D.39511 | 16;
          var2->flags = D.39512;
        }
        <D.39478>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.39513>; else goto <D.39514>;
        <D.39513>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = addr;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        addr->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = addr;
        goto <D.39515>;
        <D.39514>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = addr;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.39515>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 373;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        ins->dreg = -1;
        D.39516 = addr->dreg;
        ins->sreg1 = D.39516;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.39517>; else goto <D.39518>;
        <D.39517>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.39519>;
        <D.39518>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.39519>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 424;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        D.30978 = cfg->varinfo;
        D.39461 = vtvar->data.op[0].const_val;
        D.39462 = (long unsigned int) D.39461;
        D.39463 = D.39462 * 8;
        D.39464 = D.30978 + D.39463;
        D.39465 = *D.39464;
        D.39473 = D.39465->data.op[1].vtype;
        D.39520 = mono_type_to_regmove (cfg, D.39473);
        D.39521 = (short unsigned int) D.39520;
        ins->opcode = D.39521;
        D.30978 = cfg->varinfo;
        D.39461 = vtvar->data.op[0].const_val;
        D.39462 = (long unsigned int) D.39461;
        D.39463 = D.39462 * 8;
        D.39464 = D.30978 + D.39463;
        D.39465 = *D.39464;
        D.39473 = D.39465->data.op[1].vtype;
        type_to_eval_stack_type (cfg, D.39473, ins);
        D.30978 = cfg->varinfo;
        D.39461 = vtvar->data.op[0].const_val;
        D.39462 = (long unsigned int) D.39461;
        D.39463 = D.39462 * 8;
        D.39464 = D.30978 + D.39463;
        D.39465 = *D.39464;
        D.39468 = D.39465->klass;
        ins->klass = D.39468;
        D.30978 = cfg->varinfo;
        D.39461 = vtvar->data.op[0].const_val;
        D.39462 = (long unsigned int) D.39461;
        D.39463 = D.39462 * 8;
        D.39464 = D.30978 + D.39463;
        D.39465 = *D.39464;
        D.39480 = D.39465->dreg;
        ins->sreg1 = D.39480;
        D.30988 = ins->type;
        D.30989 = (<unnamed type>) D.30988;
        D.39522 = alloc_dreg (cfg, D.30989);
        D.39523 = (int) D.39522;
        ins->dreg = D.39523;
        D.30992 = ins->opcode;
        if (D.30992 == 427) goto <D.39524>; else goto <D.39525>;
        <D.39524>:
        D.30978 = cfg->varinfo;
        D.39461 = vtvar->data.op[0].const_val;
        D.39462 = (long unsigned int) D.39461;
        D.39463 = D.39462 * 8;
        D.39464 = D.30978 + D.39463;
        D.39465 = *D.39464;
        D.39473 = D.39465->data.op[1].vtype;
        D.39526 = mono_class_from_mono_type (D.39473);
        ins->klass = D.39526;
        <D.39525>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.39527>; else goto <D.39528>;
        <D.39527>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.39529>;
        <D.39528>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.39529>:
        ins->type = 7;
        D.39455 = mono_defaults.argumenthandle_class;
        ins->klass = D.39455;
        sp.301 = sp;
        sp = sp.301 + 8;
        *sp.301 = ins;
        ip = ip + 2;
        goto <D.28088>;
      }
      <D.28089>:
      <D.28090>:
      <D.28091>:
      <D.28092>:
      <D.28093>:
      {
        struct MonoInst * cmp;

        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        if (D.31013 <= 15) goto <D.39531>; else goto <D.39532>;
        <D.39531>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.39533>; else goto <D.39534>;
        <D.39533>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.39535>; else goto <D.39536>;
        <D.39535>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.39536>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.39534>:
        D.39537 = mini_get_debug_options ();
        D.39538 = D.39537->break_on_unverified;
        if (D.39538 != 0) goto <D.39539>; else goto unverified;
        <D.39539>:
        raise (5);
        <D.39532>:
        D.30241 = cfg->mempool;
        cmp = mono_mempool_alloc (D.30241, 80);
        cmp->data.op[1].const_val = 0;
        D.39540 = cmp->data.op[1].const_val;
        cmp->data.op[0].const_val = D.39540;
        cmp->prev = 0B;
        D.39541 = cmp->prev;
        cmp->next = D.39541;
        D.31270 = ip + 1;
        D.31271 = *D.31270;
        D.39542 = (short unsigned int) D.31271;
        D.39543 = D.39542 + 445;
        cmp->opcode = D.39543;
        cmp->flags = 0;
        cmp->type = 0;
        cmp->dreg = -1;
        cmp->sreg3 = -1;
        D.39544 = cmp->sreg3;
        cmp->sreg2 = D.39544;
        D.39545 = cmp->sreg2;
        cmp->sreg1 = D.39545;
        D.30461 = cfg->ip;
        cmp->cil_code = D.30461;
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        D.39546 = cmp->opcode;
        ins->opcode = D.39546;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        sp = sp + 18446744073709551600;
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        cmp->sreg1 = D.31422;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        D.32380 = D.32379->dreg;
        cmp->sreg2 = D.32380;
        D.31240 = *sp;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        type_from_op (cmp, D.31240, D.32379);
        D.39547 = cmp->type;
        if (D.39547 == 0) goto <D.39548>; else goto <D.39549>;
        <D.39548>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.39550>; else goto <D.39551>;
        <D.39550>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.39552>; else goto <D.39553>;
        <D.39552>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.39553>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.39551>:
        D.39554 = mini_get_debug_options ();
        D.39555 = D.39554->break_on_unverified;
        if (D.39555 != 0) goto <D.39556>; else goto unverified;
        <D.39556>:
        raise (5);
        <D.39549>:
        D.31240 = *sp;
        D.32922 = D.31240->type;
        if (D.32922 == 2) goto <D.39557>; else goto <D.39560>;
        <D.39560>:
        D.31240 = *sp;
        D.32922 = D.31240->type;
        if (D.32922 == 3) goto <D.39557>; else goto <D.39561>;
        <D.39561>:
        D.31240 = *sp;
        D.32922 = D.31240->type;
        if (D.32922 == 6) goto <D.39557>; else goto <D.39562>;
        <D.39562>:
        D.31240 = *sp;
        D.32922 = D.31240->type;
        if (D.32922 == 5) goto <D.39557>; else goto <D.39558>;
        <D.39557>:
        cmp->opcode = 325;
        goto <D.39559>;
        <D.39558>:
        D.31240 = *sp;
        D.32922 = D.31240->type;
        if (D.32922 == 4) goto <D.39563>; else goto <D.39564>;
        <D.39563>:
        cmp->opcode = 324;
        goto <D.39565>;
        <D.39564>:
        cmp->opcode = 326;
        <D.39565>:
        <D.39559>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        if (D.30577 != 0B) goto <D.39566>; else goto <D.39567>;
        <D.39566>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        D.30577->next = cmp;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        cmp->prev = D.30577;
        bblock.64 = bblock;
        bblock.64->last_ins = cmp;
        goto <D.39568>;
        <D.39567>:
        bblock.64 = bblock;
        bblock.64 = bblock;
        bblock.64->last_ins = cmp;
        D.30577 = bblock.64->last_ins;
        bblock.64->code = D.30577;
        <D.39568>:
        ins->type = 1;
        D.30988 = ins->type;
        D.30989 = (<unnamed type>) D.30988;
        D.39569 = alloc_dreg (cfg, D.30989);
        D.39570 = (int) D.39569;
        ins->dreg = D.39570;
        D.31240 = *sp;
        D.32378 = sp + 8;
        D.32379 = *D.32378;
        type_from_op (ins, D.31240, D.32379);
        D.39546 = cmp->opcode;
        if (D.39546 == 324) goto <D.39571>; else goto <D.39572>;
        <D.39571>:
        cmp->opcode = 316;
        D.39573 = cmp->sreg1;
        ins->sreg1 = D.39573;
        D.39545 = cmp->sreg2;
        ins->sreg2 = D.39545;
        <D.39572>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        if (D.30577 != 0B) goto <D.39574>; else goto <D.39575>;
        <D.39574>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        D.30577->next = ins;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        ins->prev = D.30577;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        goto <D.39576>;
        <D.39575>:
        bblock.64 = bblock;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        D.30577 = bblock.64->last_ins;
        bblock.64->code = D.30577;
        <D.39576>:
        sp.302 = sp;
        sp = sp.302 + 8;
        *sp.302 = ins;
        ip = ip + 2;
        goto <D.28088>;
      }
      <D.28095>:
      {
        struct MonoInst * argconst;
        struct MonoMethod * cil_method;

        try
          {
            sp.71 = (long int) sp;
            stack_start.72 = (long int) stack_start;
            D.31013 = sp.71 - stack_start.72;
            D.31014 = D.31013 /[ex] 8;
            D.30924 = header->max_stack;
            D.31146 = (long int) D.30924;
            if (D.31014 >= D.31146) goto <D.39578>; else goto <D.39579>;
            <D.39578>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.39580>; else goto <D.39581>;
            <D.39580>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.39582>; else goto <D.39583>;
            <D.39582>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.39583>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.39581>:
            D.39584 = mini_get_debug_options ();
            D.39585 = D.39584->break_on_unverified;
            if (D.39585 != 0) goto <D.39586>; else goto unverified;
            <D.39586>:
            raise (5);
            <D.39579>:
            D.34754 = ip + 6;
            if (D.34754 > end) goto <D.39587>; else goto <D.39588>;
            <D.39587>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.39589>; else goto <D.39590>;
            <D.39589>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.39591>; else goto <D.39592>;
            <D.39591>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.39592>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.39590>:
            D.39593 = mini_get_debug_options ();
            D.39594 = D.39593->break_on_unverified;
            if (D.39594 != 0) goto <D.39595>; else goto unverified;
            <D.39595>:
            raise (5);
            <D.39588>:
            D.31251 = ip + 2;
            D.38572 = MEM[(const guint32 *)D.31251];
            D.38573 = D.38572 << 24;
            D.31251 = ip + 2;
            D.38572 = MEM[(const guint32 *)D.31251];
            D.38574 = D.38572 >> 8;
            D.38575 = D.38574 & 65280;
            D.38576 = D.38573 | D.38575;
            D.31251 = ip + 2;
            D.38572 = MEM[(const guint32 *)D.31251];
            D.38577 = D.38572 << 8;
            D.38578 = D.38577 & 16711680;
            D.38579 = D.38576 | D.38578;
            D.31251 = ip + 2;
            D.38572 = MEM[(const guint32 *)D.31251];
            D.38580 = D.38572 >> 24;
            D.39108 = D.38579 | D.38580;
            n = (int) D.39108;
            n.148 = (unsigned int) n;
            cmethod = mini_get_method (cfg, method, n.148, 0B, generic_context);
            if (cmethod == 0B) goto <D.39596>; else goto <D.39598>;
            <D.39598>:
            D.39599 = mono_loader_get_last_error ();
            if (D.39599 != 0B) goto <D.39596>; else goto <D.39597>;
            <D.39596>:
            D.39600 = mini_get_debug_options ();
            D.39601 = D.39600->break_on_unverified;
            if (D.39601 != 0) goto <D.39602>; else goto load_error;
            <D.39602>:
            raise (5);
            <D.39597>:
            D.32125 = cmethod->klass;
            mono_class_init (D.32125);
            n.148 = (unsigned int) n;
            mono_save_token_info (cfg, image, n.148, cmethod);
            context_used = mini_method_check_context_used (cfg, cmethod);
            cil_method = cmethod;
            if (dont_verify == 0) goto <D.39603>; else goto <D.39604>;
            <D.39603>:
            D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.32142 = D.30634 & 131072;
            if (D.32142 == 0) goto <D.39605>; else goto <D.39606>;
            <D.39605>:
            D.39607 = mono_method_can_access_method (method, cmethod);
            if (D.39607 == 0) goto <D.39608>; else goto <D.39609>;
            <D.39608>:
            {
              char * method_fname;
              char * cil_method_fname;

              method_fname = mono_method_full_name (method, 1);
              cil_method_fname = mono_method_full_name (cil_method, 1);
              mono_cfg_set_exception (cfg, 9);
              D.39610 = monoeg_g_strdup_printf ("Method `%s\' is inaccessible from method `%s\'\n", cil_method_fname, method_fname);
              cfg->exception_message = D.39610;
              monoeg_g_free (method_fname);
              monoeg_g_free (cil_method_fname);
              goto exception_exit;
            }
            <D.39609>:
            <D.39606>:
            <D.39604>:
            D.39611 = mono_security_get_mode ();
            if (D.39611 == 2) goto <D.39612>; else goto <D.39613>;
            <D.39612>:
            D.39614 = check_linkdemand (cfg, method, cmethod);
            if (D.39614 != 0) goto <D.39615>; else goto <D.39616>;
            <D.39615>:
            D.30211 = cfg->method;
            if (D.30211 != method) goto <D.39617>; else goto <D.39618>;
            <D.39617>:
            D.30183 = BIT_FIELD_REF <*method, 64, 256>;
            D.30184 = D.30183 & 4467570830351532032;
            if (D.30184 == 0) goto <D.39619>; else goto <D.39620>;
            <D.39619>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 1) goto <D.39621>; else goto <D.39622>;
            <D.39621>:
            printf ("inline failed: %s\n", "linkdemand");
            <D.39622>:
            goto inline_failure;
            <D.39620>:
            <D.39618>:
            <D.39616>:
            D.30793 = cfg->exception_type;
            if (D.30793 != 0) goto exception_exit; else goto <D.39623>;
            <D.39623>:
            goto <D.39624>;
            <D.39613>:
            D.39625 = mono_security_get_mode ();
            if (D.39625 == 1) goto <D.39626>; else goto <D.39627>;
            <D.39626>:
            bblock.64 = bblock;
            ensure_method_is_allowed_to_call_method (cfg, method, cmethod, bblock.64, ip);
            <D.39627>:
            <D.39624>:
            if (sp > stack_start) goto <D.39628>; else goto <D.39629>;
            <D.39628>:
            D.39630 = ip + 11;
            if (D.39630 < end) goto <D.39631>; else goto <D.39632>;
            <D.39631>:
            bblock.64 = bblock;
            D.34754 = ip + 6;
            D.39633 = ip_in_bb (cfg, bblock.64, D.34754);
            if (D.39633 != 0) goto <D.39634>; else goto <D.39635>;
            <D.39634>:
            D.34754 = ip + 6;
            D.34755 = *D.34754;
            if (D.34755 == 115) goto <D.39636>; else goto <D.39637>;
            <D.39636>:
            {
              struct MonoMethod * ctor_method;

              D.39638 = ip + 7;
              D.39639 = MEM[(const guint32 *)D.39638];
              D.39640 = D.39639 << 24;
              D.39638 = ip + 7;
              D.39639 = MEM[(const guint32 *)D.39638];
              D.39641 = D.39639 >> 8;
              D.39642 = D.39641 & 65280;
              D.39643 = D.39640 | D.39642;
              D.39638 = ip + 7;
              D.39639 = MEM[(const guint32 *)D.39638];
              D.39644 = D.39639 << 8;
              D.39645 = D.39644 & 16711680;
              D.39646 = D.39643 | D.39645;
              D.39638 = ip + 7;
              D.39639 = MEM[(const guint32 *)D.39638];
              D.39647 = D.39639 >> 24;
              D.39648 = D.39646 | D.39647;
              ctor_method = mini_get_method (cfg, method, D.39648, 0B, generic_context);
              if (ctor_method != 0B) goto <D.39649>; else goto <D.39650>;
              <D.39649>:
              D.39651 = ctor_method->klass;
              D.39652 = D.39651->parent;
              D.32591 = mono_defaults.multicastdelegate_class;
              if (D.39652 == D.32591) goto <D.39653>; else goto <D.39654>;
              <D.39653>:
              {
                struct MonoInst * target_ins;
                struct MonoMethod * invoke;
                int invoke_context_used;

                D.39651 = ctor_method->klass;
                invoke = mono_get_delegate_invoke (D.39651);
                if (invoke == 0B) goto <D.39655>; else goto <D.39657>;
                <D.39657>:
                D.39658 = mono_method_signature (invoke);
                if (D.39658 == 0B) goto <D.39655>; else goto <D.39656>;
                <D.39655>:
                D.39659 = mini_get_debug_options ();
                D.39660 = D.39659->break_on_unverified;
                if (D.39660 != 0) goto <D.39661>; else goto load_error;
                <D.39661>:
                raise (5);
                <D.39656>:
                invoke_context_used = mini_method_check_context_used (cfg, invoke);
                target_ins = MEM[(struct MonoInst * *)sp + -8B];
                D.39662 = mono_security_get_mode ();
                if (D.39662 == 1) goto <D.39663>; else goto <D.39664>;
                <D.39663>:
                bblock.64 = bblock;
                ensure_method_is_allowed_to_call_method (cfg, method, ctor_method, bblock.64, ip);
                <D.39664>:
                D.32161 = cmethod->flags;
                D.32162 = (int) D.32161;
                D.39665 = D.32162 & 16;
                if (D.39665 == 0) goto <D.39666>; else goto <D.39667>;
                <D.39666>:
                D.39668 = mono_method_signature (invoke);
                D.39669 = D.39668->param_count;
                D.39670 = mono_method_signature (cmethod);
                D.39671 = D.39670->param_count;
                if (D.39669 == D.39671) goto <D.39672>; else goto <D.39673>;
                <D.39672>:
                {
                  struct MonoInst * inst;

                  D.30241 = cfg->mempool;
                  inst = mono_mempool_alloc (D.30241, 80);
                  inst->data.op[1].const_val = 0;
                  D.39674 = inst->data.op[1].const_val;
                  inst->data.op[0].const_val = D.39674;
                  inst->prev = 0B;
                  D.39675 = inst->prev;
                  inst->next = D.39675;
                  inst->opcode = 323;
                  inst->flags = 0;
                  inst->type = 0;
                  inst->dreg = -1;
                  inst->sreg3 = -1;
                  D.39676 = inst->sreg3;
                  inst->sreg2 = D.39676;
                  D.39677 = inst->sreg2;
                  inst->sreg1 = D.39677;
                  D.30461 = cfg->ip;
                  inst->cil_code = D.30461;
                  inst->dreg = -1;
                  D.39678 = target_ins->dreg;
                  inst->sreg1 = D.39678;
                  inst->data.op[1].const_val = 0;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.39679>; else goto <D.39680>;
                  <D.39679>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.30490->next = inst;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  inst->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  bblock.106->last_ins = inst;
                  goto <D.39681>;
                  <D.39680>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  bblock.106->last_ins = inst;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.39681>:
                }
                {
                  struct MonoInst * inst;

                  D.30241 = cfg->mempool;
                  inst = mono_mempool_alloc (D.30241, 80);
                  inst->data.op[1].const_val = 0;
                  D.39682 = inst->data.op[1].const_val;
                  inst->data.op[0].const_val = D.39682;
                  inst->prev = 0B;
                  D.39683 = inst->prev;
                  inst->next = D.39683;
                  inst->opcode = 451;
                  inst->flags = 0;
                  inst->type = 0;
                  inst->dreg = -1;
                  inst->sreg3 = -1;
                  D.39684 = inst->sreg3;
                  inst->sreg2 = D.39684;
                  D.39685 = inst->sreg2;
                  inst->sreg1 = D.39685;
                  D.30461 = cfg->ip;
                  inst->cil_code = D.30461;
                  inst->data.op[1].p = "ArgumentException";
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  if (D.30490 != 0B) goto <D.39686>; else goto <D.39687>;
                  <D.39686>:
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  D.30490->next = inst;
                  bblock.106 = cfg->cbb;
                  D.30490 = bblock.106->last_ins;
                  inst->prev = D.30490;
                  bblock.106 = cfg->cbb;
                  bblock.106->last_ins = inst;
                  goto <D.39688>;
                  <D.39687>:
                  bblock.106 = cfg->cbb;
                  bblock.106 = cfg->cbb;
                  bblock.106->last_ins = inst;
                  D.30490 = bblock.106->last_ins;
                  bblock.106->code = D.30490;
                  <D.39688>:
                }
                <D.39673>:
                <D.39667>:
                if (invoke_context_used == 0) goto <D.39689>; else goto <D.39690>;
                <D.39689>:
                ip = ip + 6;
                D.30322 = cfg->verbose_level;
                if (D.30322 > 3) goto <D.39691>; else goto <D.39692>;
                <D.39691>:
                bblock.64 = bblock;
                D.31119 = bblock.64->block_num;
                sp.71 = (long int) sp;
                stack_start.72 = (long int) stack_start;
                D.31013 = sp.71 - stack_start.72;
                D.31014 = D.31013 /[ex] 8;
                D.31015 = (int) D.31014;
                D.39693 = mono_disasm_code_one (0B, method, ip, 0B);
                monoeg_g_print ("converting (in B%d: stack: %d) %s", D.31119, D.31015, D.39693);
                <D.39692>:
                sp = sp + 18446744073709551608;
                D.39651 = ctor_method->klass;
                D.39694 = handle_delegate_ctor (cfg, D.39651, target_ins, cmethod, context_used);
                *sp = D.39694;
                D.30793 = cfg->exception_type;
                if (D.30793 != 0) goto exception_exit; else goto <D.39695>;
                <D.39695>:
                ip = ip + 5;
                sp = sp + 8;
                goto <D.28088>;
                <D.39690>:
              }
              <D.39654>:
              <D.39650>:
            }
            <D.39637>:
            <D.39635>:
            <D.39632>:
            <D.39629>:
            argconst.303 = emit_get_rgctx_method (cfg, context_used, cmethod, 5);
            argconst = argconst.303;
            ins = mono_emit_jit_icall (cfg, mono_ldftn, &argconst);
            sp.304 = sp;
            sp = sp.304 + 8;
            *sp.304 = ins;
            ip = ip + 6;
            num_calls.305 = num_calls;
            num_calls = num_calls.305 + 1;
            D.39699 = num_calls.305 * 10;
            inline_costs = D.39699 + inline_costs;
            goto <D.28088>;
          }
        finally
          {
            argconst = {CLOBBER};
          }
      }
      <D.28106>:
      {
        struct MonoInst * args[2];

        try
          {
            sp.71 = (long int) sp;
            stack_start.72 = (long int) stack_start;
            D.31013 = sp.71 - stack_start.72;
            if (D.31013 <= 7) goto <D.39700>; else goto <D.39701>;
            <D.39700>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.39702>; else goto <D.39703>;
            <D.39702>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.39704>; else goto <D.39705>;
            <D.39704>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.39705>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.39703>:
            D.39706 = mini_get_debug_options ();
            D.39707 = D.39706->break_on_unverified;
            if (D.39707 != 0) goto <D.39708>; else goto unverified;
            <D.39708>:
            raise (5);
            <D.39701>:
            D.34754 = ip + 6;
            if (D.34754 > end) goto <D.39709>; else goto <D.39710>;
            <D.39709>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.39711>; else goto <D.39712>;
            <D.39711>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.39713>; else goto <D.39714>;
            <D.39713>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.39714>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.39712>:
            D.39715 = mini_get_debug_options ();
            D.39716 = D.39715->break_on_unverified;
            if (D.39716 != 0) goto <D.39717>; else goto unverified;
            <D.39717>:
            raise (5);
            <D.39710>:
            D.31251 = ip + 2;
            D.38572 = MEM[(const guint32 *)D.31251];
            D.38573 = D.38572 << 24;
            D.31251 = ip + 2;
            D.38572 = MEM[(const guint32 *)D.31251];
            D.38574 = D.38572 >> 8;
            D.38575 = D.38574 & 65280;
            D.38576 = D.38573 | D.38575;
            D.31251 = ip + 2;
            D.38572 = MEM[(const guint32 *)D.31251];
            D.38577 = D.38572 << 8;
            D.38578 = D.38577 & 16711680;
            D.38579 = D.38576 | D.38578;
            D.31251 = ip + 2;
            D.38572 = MEM[(const guint32 *)D.31251];
            D.38580 = D.38572 >> 24;
            D.39108 = D.38579 | D.38580;
            n = (int) D.39108;
            n.148 = (unsigned int) n;
            cmethod = mini_get_method (cfg, method, n.148, 0B, generic_context);
            if (cmethod == 0B) goto <D.39718>; else goto <D.39720>;
            <D.39720>:
            D.39721 = mono_loader_get_last_error ();
            if (D.39721 != 0B) goto <D.39718>; else goto <D.39719>;
            <D.39718>:
            D.39722 = mini_get_debug_options ();
            D.39723 = D.39722->break_on_unverified;
            if (D.39723 != 0) goto <D.39724>; else goto load_error;
            <D.39724>:
            raise (5);
            <D.39719>:
            D.32125 = cmethod->klass;
            mono_class_init (D.32125);
            context_used = mini_method_check_context_used (cfg, cmethod);
            D.39725 = mono_security_get_mode ();
            if (D.39725 == 2) goto <D.39726>; else goto <D.39727>;
            <D.39726>:
            D.39728 = check_linkdemand (cfg, method, cmethod);
            if (D.39728 != 0) goto <D.39729>; else goto <D.39730>;
            <D.39729>:
            D.30211 = cfg->method;
            if (D.30211 != method) goto <D.39731>; else goto <D.39732>;
            <D.39731>:
            D.30183 = BIT_FIELD_REF <*method, 64, 256>;
            D.30184 = D.30183 & 4467570830351532032;
            if (D.30184 == 0) goto <D.39733>; else goto <D.39734>;
            <D.39733>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 1) goto <D.39735>; else goto <D.39736>;
            <D.39735>:
            printf ("inline failed: %s\n", "linkdemand");
            <D.39736>:
            goto inline_failure;
            <D.39734>:
            <D.39732>:
            <D.39730>:
            D.30793 = cfg->exception_type;
            if (D.30793 != 0) goto exception_exit; else goto <D.39737>;
            <D.39737>:
            goto <D.39738>;
            <D.39727>:
            D.39739 = mono_security_get_mode ();
            if (D.39739 == 1) goto <D.39740>; else goto <D.39741>;
            <D.39740>:
            bblock.64 = bblock;
            ensure_method_is_allowed_to_call_method (cfg, method, cmethod, bblock.64, ip);
            <D.39741>:
            <D.39738>:
            sp = sp + 18446744073709551608;
            D.31240 = *sp;
            args[0] = D.31240;
            D.39742 = emit_get_rgctx_method (cfg, context_used, cmethod, 5);
            args[1] = D.39742;
            if (context_used != 0) goto <D.39743>; else goto <D.39744>;
            <D.39743>:
            sp.306 = sp;
            sp = sp.306 + 8;
            D.39746 = mono_emit_jit_icall (cfg, mono_ldvirtfn_gshared, &args);
            *sp.306 = D.39746;
            goto <D.39747>;
            <D.39744>:
            sp.307 = sp;
            sp = sp.307 + 8;
            D.39749 = mono_emit_jit_icall (cfg, mono_ldvirtfn, &args);
            *sp.307 = D.39749;
            <D.39747>:
            ip = ip + 6;
            num_calls.308 = num_calls;
            num_calls = num_calls.308 + 1;
            D.39751 = num_calls.308 * 10;
            inline_costs = D.39751 + inline_costs;
            goto <D.28088>;
          }
        finally
          {
            args = {CLOBBER};
          }
      }
      <D.28108>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.30924 = header->max_stack;
      D.31146 = (long int) D.30924;
      if (D.31014 >= D.31146) goto <D.39752>; else goto <D.39753>;
      <D.39752>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.39754>; else goto <D.39755>;
      <D.39754>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39756>; else goto <D.39757>;
      <D.39756>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39757>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39755>:
      D.39758 = mini_get_debug_options ();
      D.39759 = D.39758->break_on_unverified;
      if (D.39759 != 0) goto <D.39760>; else goto unverified;
      <D.39760>:
      raise (5);
      <D.39753>:
      D.39761 = ip + 4;
      if (D.39761 > end) goto <D.39762>; else goto <D.39763>;
      <D.39762>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.39764>; else goto <D.39765>;
      <D.39764>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39766>; else goto <D.39767>;
      <D.39766>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39767>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39765>:
      D.39768 = mini_get_debug_options ();
      D.39769 = D.39768->break_on_unverified;
      if (D.39769 != 0) goto <D.39770>; else goto unverified;
      <D.39770>:
      raise (5);
      <D.39763>:
      D.31251 = ip + 2;
      D.39771 = MEM[(const guint16 *)D.31251];
      D.39772 = D.39771 >> 8;
      D.39773 = (int) D.39772;
      D.31251 = ip + 2;
      D.39771 = MEM[(const guint16 *)D.31251];
      D.39774 = (int) D.39771;
      D.39775 = D.39774 << 8;
      D.39776 = D.39775 & 65535;
      n = D.39773 | D.39776;
      n.75 = (unsigned int) n;
      if (n.75 >= num_args) goto <D.39777>; else goto <D.39778>;
      <D.39777>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.39779>; else goto <D.39780>;
      <D.39779>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39781>; else goto <D.39782>;
      <D.39781>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39782>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39780>:
      D.39783 = mini_get_debug_options ();
      D.39784 = D.39783->break_on_unverified;
      if (D.39784 != 0) goto <D.39785>; else goto unverified;
      <D.39785>:
      raise (5);
      <D.39778>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.30852 = cfg->arg_types;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31168 = D.30852 + D.31167;
      D.31169 = *D.31168;
      D.39786 = mono_type_to_regmove (cfg, D.31169);
      D.39787 = (short unsigned int) D.39786;
      ins->opcode = D.39787;
      D.30852 = cfg->arg_types;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31168 = D.30852 + D.31167;
      D.31169 = *D.31168;
      type_to_eval_stack_type (cfg, D.31169, ins);
      D.30842 = cfg->args;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31172 = D.30842 + D.31167;
      D.31173 = *D.31172;
      D.31174 = D.31173->klass;
      ins->klass = D.31174;
      D.30842 = cfg->args;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31172 = D.30842 + D.31167;
      D.31173 = *D.31172;
      D.31175 = D.31173->dreg;
      ins->sreg1 = D.31175;
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.39788 = alloc_dreg (cfg, D.30989);
      D.39789 = (int) D.39788;
      ins->dreg = D.39789;
      D.30992 = ins->opcode;
      if (D.30992 == 427) goto <D.39790>; else goto <D.39791>;
      <D.39790>:
      D.30852 = cfg->arg_types;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31168 = D.30852 + D.31167;
      D.31169 = *D.31168;
      D.39792 = mono_class_from_mono_type (D.31169);
      ins->klass = D.39792;
      <D.39791>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.39793>; else goto <D.39794>;
      <D.39793>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.39795>;
      <D.39794>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.39795>:
      sp.309 = sp;
      sp = sp.309 + 8;
      *sp.309 = ins;
      ip = ip + 4;
      goto <D.28088>;
      <D.28109>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.30924 = header->max_stack;
      D.31146 = (long int) D.30924;
      if (D.31014 >= D.31146) goto <D.39797>; else goto <D.39798>;
      <D.39797>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.39799>; else goto <D.39800>;
      <D.39799>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39801>; else goto <D.39802>;
      <D.39801>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39802>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39800>:
      D.39803 = mini_get_debug_options ();
      D.39804 = D.39803->break_on_unverified;
      if (D.39804 != 0) goto <D.39805>; else goto unverified;
      <D.39805>:
      raise (5);
      <D.39798>:
      D.39761 = ip + 4;
      if (D.39761 > end) goto <D.39806>; else goto <D.39807>;
      <D.39806>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.39808>; else goto <D.39809>;
      <D.39808>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39810>; else goto <D.39811>;
      <D.39810>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39811>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39809>:
      D.39812 = mini_get_debug_options ();
      D.39813 = D.39812->break_on_unverified;
      if (D.39813 != 0) goto <D.39814>; else goto unverified;
      <D.39814>:
      raise (5);
      <D.39807>:
      D.31251 = ip + 2;
      D.39771 = MEM[(const guint16 *)D.31251];
      D.39772 = D.39771 >> 8;
      D.39773 = (int) D.39772;
      D.31251 = ip + 2;
      D.39771 = MEM[(const guint16 *)D.31251];
      D.39774 = (int) D.39771;
      D.39775 = D.39774 << 8;
      D.39776 = D.39775 & 65535;
      n = D.39773 | D.39776;
      n.75 = (unsigned int) n;
      if (n.75 >= num_args) goto <D.39815>; else goto <D.39816>;
      <D.39815>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.39817>; else goto <D.39818>;
      <D.39817>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39819>; else goto <D.39820>;
      <D.39819>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39820>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39818>:
      D.39821 = mini_get_debug_options ();
      D.39822 = D.39821->break_on_unverified;
      if (D.39822 != 0) goto <D.39823>; else goto unverified;
      <D.39823>:
      raise (5);
      <D.39816>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 314;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31319 = arg_array + D.31167;
      D.31320 = *D.31319;
      ins->data.op[0].p = D.31320;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31319 = arg_array + D.31167;
      D.31320 = *D.31319;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31319 = arg_array + D.31167;
      D.31320 = *D.31319;
      D.31321 = D.31320->flags;
      D.31322 = D.31321 | 16;
      D.31320->flags = D.31322;
      ins->type = 5;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31319 = arg_array + D.31167;
      D.31320 = *D.31319;
      D.31323 = D.31320->klass;
      ins->klass = D.31323;
      D.39824 = alloc_dreg (cfg, 5);
      D.39825 = (int) D.39824;
      ins->dreg = D.39825;
      cfg->has_indirection = 1;
      D.30389 = cfg->gsharedvt;
      D.31326 = D.30389 != 0;
      D.31327 = (long int) D.31326;
      D.31328 = __builtin_expect (D.31327, 0);
      if (D.31328 != 0) goto <D.39826>; else goto <D.39827>;
      <D.39826>:
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31319 = arg_array + D.31167;
      D.31320 = *D.31319;
      D.31331 = D.31320->data.op[1].vtype;
      D.39828 = mini_is_gsharedvt_variable_type (cfg, D.31331);
      if (D.39828 != 0) goto <D.39829>; else goto <D.39830>;
      <D.39829>:
      handle_gsharedvt_ldaddr (cfg);
      <D.39830>:
      <D.39827>:
      if (0 != 0) goto <D.39831>; else goto <D.39832>;
      <D.39831>:
      {
        struct MonoInst * var1;
        struct MonoInst * var2;

        D.31166 = (long unsigned int) n;
        D.31167 = D.31166 * 8;
        D.31319 = arg_array + D.31167;
        D.31320 = *D.31319;
        D.31338 = D.31320->dreg;
        D.31339 = D.31338 + 1;
        D.31340 = (unsigned int) D.31339;
        D.31341 = cfg->vreg_to_inst_len;
        if (D.31340 < D.31341) goto <D.39834>; else goto <D.39835>;
        <D.39834>:
        D.31344 = cfg->vreg_to_inst;
        D.31166 = (long unsigned int) n;
        D.31167 = D.31166 * 8;
        D.31319 = arg_array + D.31167;
        D.31320 = *D.31319;
        D.31338 = D.31320->dreg;
        D.31345 = (sizetype) D.31338;
        D.31346 = D.31345 + 1;
        D.31347 = D.31346 * 8;
        D.31348 = D.31344 + D.31347;
        iftmp.310 = *D.31348;
        goto <D.39836>;
        <D.39835>:
        iftmp.310 = 0B;
        <D.39836>:
        var1 = iftmp.310;
        D.31166 = (long unsigned int) n;
        D.31167 = D.31166 * 8;
        D.31319 = arg_array + D.31167;
        D.31320 = *D.31319;
        D.31338 = D.31320->dreg;
        D.31351 = D.31338 + 2;
        D.31352 = (unsigned int) D.31351;
        D.31341 = cfg->vreg_to_inst_len;
        if (D.31352 < D.31341) goto <D.39838>; else goto <D.39839>;
        <D.39838>:
        D.31344 = cfg->vreg_to_inst;
        D.31166 = (long unsigned int) n;
        D.31167 = D.31166 * 8;
        D.31319 = arg_array + D.31167;
        D.31320 = *D.31319;
        D.31338 = D.31320->dreg;
        D.31345 = (sizetype) D.31338;
        D.31355 = D.31345 + 2;
        D.31356 = D.31355 * 8;
        D.31357 = D.31344 + D.31356;
        iftmp.311 = *D.31357;
        goto <D.39840>;
        <D.39839>:
        iftmp.311 = 0B;
        <D.39840>:
        var2 = iftmp.311;
        D.39841 = var1 == 0B;
        D.39842 = (long int) D.39841;
        D.39843 = __builtin_expect (D.39842, 0);
        if (D.39843 != 0) goto <D.39844>; else goto <D.39845>;
        <D.39844>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11584, "var1");
        <D.39845>:
        D.39846 = var2 == 0B;
        D.39847 = (long int) D.39846;
        D.39848 = __builtin_expect (D.39847, 0);
        if (D.39848 != 0) goto <D.39849>; else goto <D.39850>;
        <D.39849>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11584, "var2");
        <D.39850>:
        D.39851 = var1->flags;
        D.39852 = D.39851 | 16;
        var1->flags = D.39852;
        D.39853 = var2->flags;
        D.39854 = D.39853 | 16;
        var2->flags = D.39854;
      }
      <D.39832>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.39855>; else goto <D.39856>;
      <D.39855>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.39857>;
      <D.39856>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.39857>:
      sp.312 = sp;
      sp = sp.312 + 8;
      *sp.312 = ins;
      ip = ip + 4;
      goto <D.28088>;
      <D.28112>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.39859>; else goto <D.39860>;
      <D.39859>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.39861>; else goto <D.39862>;
      <D.39861>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39863>; else goto <D.39864>;
      <D.39863>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39864>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39862>:
      D.39865 = mini_get_debug_options ();
      D.39866 = D.39865->break_on_unverified;
      if (D.39866 != 0) goto <D.39867>; else goto unverified;
      <D.39867>:
      raise (5);
      <D.39860>:
      sp = sp + 18446744073709551608;
      D.39761 = ip + 4;
      if (D.39761 > end) goto <D.39868>; else goto <D.39869>;
      <D.39868>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.39870>; else goto <D.39871>;
      <D.39870>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39872>; else goto <D.39873>;
      <D.39872>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39873>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39871>:
      D.39874 = mini_get_debug_options ();
      D.39875 = D.39874->break_on_unverified;
      if (D.39875 != 0) goto <D.39876>; else goto unverified;
      <D.39876>:
      raise (5);
      <D.39869>:
      D.31251 = ip + 2;
      D.39771 = MEM[(const guint16 *)D.31251];
      D.39772 = D.39771 >> 8;
      D.39773 = (int) D.39772;
      D.31251 = ip + 2;
      D.39771 = MEM[(const guint16 *)D.31251];
      D.39774 = (int) D.39771;
      D.39775 = D.39774 << 8;
      D.39776 = D.39775 & 65535;
      n = D.39773 | D.39776;
      n.75 = (unsigned int) n;
      if (n.75 >= num_args) goto <D.39877>; else goto <D.39878>;
      <D.39877>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.39879>; else goto <D.39880>;
      <D.39879>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39881>; else goto <D.39882>;
      <D.39881>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39882>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39880>:
      D.39883 = mini_get_debug_options ();
      D.39884 = D.39883->break_on_unverified;
      if (D.39884 != 0) goto <D.39885>; else goto unverified;
      <D.39885>:
      raise (5);
      <D.39878>:
      if (dont_verify_stloc == 0) goto <D.39886>; else goto <D.39887>;
      <D.39886>:
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.39888 = param_types + D.31167;
      D.39889 = *D.39888;
      D.31240 = *sp;
      D.39890 = target_type_is_incompatible (cfg, D.39889, D.31240);
      if (D.39890 != 0) goto <D.39891>; else goto <D.39892>;
      <D.39891>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.39893>; else goto <D.39894>;
      <D.39893>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39895>; else goto <D.39896>;
      <D.39895>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39896>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39894>:
      D.39897 = mini_get_debug_options ();
      D.39898 = D.39897->break_on_unverified;
      if (D.39898 != 0) goto <D.39899>; else goto unverified;
      <D.39899>:
      raise (5);
      <D.39892>:
      <D.39887>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.30852 = cfg->arg_types;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31168 = D.30852 + D.31167;
      D.31169 = *D.31168;
      D.39900 = mono_type_to_regmove (cfg, D.31169);
      D.39901 = (short unsigned int) D.39900;
      ins->opcode = D.39901;
      D.30842 = cfg->args;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31172 = D.30842 + D.31167;
      D.31173 = *D.31172;
      D.31174 = D.31173->klass;
      ins->klass = D.31174;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      D.30842 = cfg->args;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31172 = D.30842 + D.31167;
      D.31173 = *D.31172;
      D.31175 = D.31173->dreg;
      ins->dreg = D.31175;
      D.30992 = ins->opcode;
      if (D.30992 == 427) goto <D.39902>; else goto <D.39903>;
      <D.39902>:
      D.30852 = cfg->arg_types;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31168 = D.30852 + D.31167;
      D.31169 = *D.31168;
      D.39904 = mono_class_from_mono_type (D.31169);
      ins->klass = D.39904;
      <D.39903>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.39905>; else goto <D.39906>;
      <D.39905>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.39907>;
      <D.39906>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.39907>:
      ip = ip + 4;
      goto <D.28088>;
      <D.28113>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      D.31014 = D.31013 /[ex] 8;
      D.30924 = header->max_stack;
      D.31146 = (long int) D.30924;
      if (D.31014 >= D.31146) goto <D.39908>; else goto <D.39909>;
      <D.39908>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.39910>; else goto <D.39911>;
      <D.39910>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39912>; else goto <D.39913>;
      <D.39912>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39913>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39911>:
      D.39914 = mini_get_debug_options ();
      D.39915 = D.39914->break_on_unverified;
      if (D.39915 != 0) goto <D.39916>; else goto unverified;
      <D.39916>:
      raise (5);
      <D.39909>:
      D.39761 = ip + 4;
      if (D.39761 > end) goto <D.39917>; else goto <D.39918>;
      <D.39917>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.39919>; else goto <D.39920>;
      <D.39919>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39921>; else goto <D.39922>;
      <D.39921>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39922>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39920>:
      D.39923 = mini_get_debug_options ();
      D.39924 = D.39923->break_on_unverified;
      if (D.39924 != 0) goto <D.39925>; else goto unverified;
      <D.39925>:
      raise (5);
      <D.39918>:
      D.31251 = ip + 2;
      D.39771 = MEM[(const guint16 *)D.31251];
      D.39772 = D.39771 >> 8;
      D.39773 = (int) D.39772;
      D.31251 = ip + 2;
      D.39771 = MEM[(const guint16 *)D.31251];
      D.39774 = (int) D.39771;
      D.39775 = D.39774 << 8;
      D.39776 = D.39775 & 65535;
      n = D.39773 | D.39776;
      D.30829 = header->num_locals;
      D.31194 = (unsigned int) D.30829;
      n.75 = (unsigned int) n;
      if (D.31194 <= n.75) goto <D.39926>; else goto <D.39927>;
      <D.39926>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.39928>; else goto <D.39929>;
      <D.39928>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.39930>; else goto <D.39931>;
      <D.39930>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.39931>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.39929>:
      D.39932 = mini_get_debug_options ();
      D.39933 = D.39932->break_on_unverified;
      if (D.39933 != 0) goto <D.39934>; else goto unverified;
      <D.39934>:
      raise (5);
      <D.39927>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 424;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.30817 = header->locals[n];
      D.39935 = mono_type_to_regmove (cfg, D.30817);
      D.39936 = (short unsigned int) D.39935;
      ins->opcode = D.39936;
      D.30817 = header->locals[n];
      type_to_eval_stack_type (cfg, D.30817, ins);
      D.31206 = cfg->locals;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31207 = D.31206 + D.31167;
      D.31208 = *D.31207;
      D.31209 = D.31208->klass;
      ins->klass = D.31209;
      D.31206 = cfg->locals;
      D.31166 = (long unsigned int) n;
      D.31167 = D.31166 * 8;
      D.31207 = D.31206 + D.31167;
      D.31208 = *D.31207;
      D.31210 = D.31208->dreg;
      ins->sreg1 = D.31210;
      D.30988 = ins->type;
      D.30989 = (<unnamed type>) D.30988;
      D.39937 = alloc_dreg (cfg, D.30989);
      D.39938 = (int) D.39937;
      ins->dreg = D.39938;
      D.30992 = ins->opcode;
      if (D.30992 == 427) goto <D.39939>; else goto <D.39940>;
      <D.39939>:
      D.30817 = header->locals[n];
      D.39941 = mono_class_from_mono_type (D.30817);
      ins->klass = D.39941;
      <D.39940>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.39942>; else goto <D.39943>;
      <D.39942>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.39944>;
      <D.39943>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.39944>:
      sp.313 = sp;
      sp = sp.313 + 8;
      *sp.313 = ins;
      ip = ip + 4;
      goto <D.28088>;
      <D.28114>:
      {
        unsigned char * tmp_ip;

        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        D.31014 = D.31013 /[ex] 8;
        D.30924 = header->max_stack;
        D.31146 = (long int) D.30924;
        if (D.31014 >= D.31146) goto <D.39946>; else goto <D.39947>;
        <D.39946>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.39948>; else goto <D.39949>;
        <D.39948>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.39950>; else goto <D.39951>;
        <D.39950>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.39951>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.39949>:
        D.39952 = mini_get_debug_options ();
        D.39953 = D.39952->break_on_unverified;
        if (D.39953 != 0) goto <D.39954>; else goto unverified;
        <D.39954>:
        raise (5);
        <D.39947>:
        D.39761 = ip + 4;
        if (D.39761 > end) goto <D.39955>; else goto <D.39956>;
        <D.39955>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.39957>; else goto <D.39958>;
        <D.39957>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.39959>; else goto <D.39960>;
        <D.39959>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.39960>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.39958>:
        D.39961 = mini_get_debug_options ();
        D.39962 = D.39961->break_on_unverified;
        if (D.39962 != 0) goto <D.39963>; else goto unverified;
        <D.39963>:
        raise (5);
        <D.39956>:
        D.31251 = ip + 2;
        D.39771 = MEM[(const guint16 *)D.31251];
        D.39772 = D.39771 >> 8;
        D.39773 = (int) D.39772;
        D.31251 = ip + 2;
        D.39771 = MEM[(const guint16 *)D.31251];
        D.39774 = (int) D.39771;
        D.39775 = D.39774 << 8;
        D.39776 = D.39775 & 65535;
        n = D.39773 | D.39776;
        D.30829 = header->num_locals;
        D.31194 = (unsigned int) D.30829;
        n.75 = (unsigned int) n;
        if (D.31194 <= n.75) goto <D.39964>; else goto <D.39965>;
        <D.39964>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.39966>; else goto <D.39967>;
        <D.39966>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.39968>; else goto <D.39969>;
        <D.39968>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.39969>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.39967>:
        D.39970 = mini_get_debug_options ();
        D.39971 = D.39970->break_on_unverified;
        if (D.39971 != 0) goto <D.39972>; else goto unverified;
        <D.39972>:
        raise (5);
        <D.39965>:
        tmp_ip = emit_optimized_ldloca_ir (cfg, ip, end, 2);
        if (tmp_ip != 0B) goto <D.39973>; else goto <D.39974>;
        <D.39973>:
        ip = tmp_ip;
        inline_costs = inline_costs + 1;
        goto <D.28088>;
        <D.39974>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 314;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        D.31206 = cfg->locals;
        D.31166 = (long unsigned int) n;
        D.31167 = D.31166 * 8;
        D.31207 = D.31206 + D.31167;
        D.31208 = *D.31207;
        ins->data.op[0].p = D.31208;
        D.31206 = cfg->locals;
        D.31166 = (long unsigned int) n;
        D.31167 = D.31166 * 8;
        D.31207 = D.31206 + D.31167;
        D.31208 = *D.31207;
        D.31206 = cfg->locals;
        D.31166 = (long unsigned int) n;
        D.31167 = D.31166 * 8;
        D.31207 = D.31206 + D.31167;
        D.31208 = *D.31207;
        D.39975 = D.31208->flags;
        D.39976 = D.39975 | 16;
        D.31208->flags = D.39976;
        ins->type = 5;
        D.31206 = cfg->locals;
        D.31166 = (long unsigned int) n;
        D.31167 = D.31166 * 8;
        D.31207 = D.31206 + D.31167;
        D.31208 = *D.31207;
        D.31209 = D.31208->klass;
        ins->klass = D.31209;
        D.39977 = alloc_dreg (cfg, 5);
        D.39978 = (int) D.39977;
        ins->dreg = D.39978;
        cfg->has_indirection = 1;
        D.30389 = cfg->gsharedvt;
        D.31326 = D.30389 != 0;
        D.31327 = (long int) D.31326;
        D.31328 = __builtin_expect (D.31327, 0);
        if (D.31328 != 0) goto <D.39979>; else goto <D.39980>;
        <D.39979>:
        D.31206 = cfg->locals;
        D.31166 = (long unsigned int) n;
        D.31167 = D.31166 * 8;
        D.31207 = D.31206 + D.31167;
        D.31208 = *D.31207;
        D.39981 = D.31208->data.op[1].vtype;
        D.39982 = mini_is_gsharedvt_variable_type (cfg, D.39981);
        if (D.39982 != 0) goto <D.39983>; else goto <D.39984>;
        <D.39983>:
        handle_gsharedvt_ldaddr (cfg);
        <D.39984>:
        <D.39980>:
        if (0 != 0) goto <D.39985>; else goto <D.39986>;
        <D.39985>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.31206 = cfg->locals;
          D.31166 = (long unsigned int) n;
          D.31167 = D.31166 * 8;
          D.31207 = D.31206 + D.31167;
          D.31208 = *D.31207;
          D.31210 = D.31208->dreg;
          D.39988 = D.31210 + 1;
          D.39989 = (unsigned int) D.39988;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.39989 < D.31341) goto <D.39990>; else goto <D.39991>;
          <D.39990>:
          D.31344 = cfg->vreg_to_inst;
          D.31206 = cfg->locals;
          D.31166 = (long unsigned int) n;
          D.31167 = D.31166 * 8;
          D.31207 = D.31206 + D.31167;
          D.31208 = *D.31207;
          D.31210 = D.31208->dreg;
          D.39992 = (sizetype) D.31210;
          D.39993 = D.39992 + 1;
          D.39994 = D.39993 * 8;
          D.39995 = D.31344 + D.39994;
          iftmp.314 = *D.39995;
          goto <D.39996>;
          <D.39991>:
          iftmp.314 = 0B;
          <D.39996>:
          var1 = iftmp.314;
          D.31206 = cfg->locals;
          D.31166 = (long unsigned int) n;
          D.31167 = D.31166 * 8;
          D.31207 = D.31206 + D.31167;
          D.31208 = *D.31207;
          D.31210 = D.31208->dreg;
          D.39998 = D.31210 + 2;
          D.39999 = (unsigned int) D.39998;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.39999 < D.31341) goto <D.40000>; else goto <D.40001>;
          <D.40000>:
          D.31344 = cfg->vreg_to_inst;
          D.31206 = cfg->locals;
          D.31166 = (long unsigned int) n;
          D.31167 = D.31166 * 8;
          D.31207 = D.31206 + D.31167;
          D.31208 = *D.31207;
          D.31210 = D.31208->dreg;
          D.39992 = (sizetype) D.31210;
          D.40002 = D.39992 + 2;
          D.40003 = D.40002 * 8;
          D.40004 = D.31344 + D.40003;
          iftmp.315 = *D.40004;
          goto <D.40005>;
          <D.40001>:
          iftmp.315 = 0B;
          <D.40005>:
          var2 = iftmp.315;
          D.40006 = var1 == 0B;
          D.40007 = (long int) D.40006;
          D.40008 = __builtin_expect (D.40007, 0);
          if (D.40008 != 0) goto <D.40009>; else goto <D.40010>;
          <D.40009>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11622, "var1");
          <D.40010>:
          D.40011 = var2 == 0B;
          D.40012 = (long int) D.40011;
          D.40013 = __builtin_expect (D.40012, 0);
          if (D.40013 != 0) goto <D.40014>; else goto <D.40015>;
          <D.40014>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11622, "var2");
          <D.40015>:
          D.40016 = var1->flags;
          D.40017 = D.40016 | 16;
          var1->flags = D.40017;
          D.40018 = var2->flags;
          D.40019 = D.40018 | 16;
          var2->flags = D.40019;
        }
        <D.39986>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.40020>; else goto <D.40021>;
        <D.40020>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.40022>;
        <D.40021>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.40022>:
        sp.316 = sp;
        sp = sp.316 + 8;
        *sp.316 = ins;
        ip = ip + 4;
        goto <D.28088>;
      }
      <D.28118>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.40024>; else goto <D.40025>;
      <D.40024>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.40026>; else goto <D.40027>;
      <D.40026>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.40028>; else goto <D.40029>;
      <D.40028>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40029>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40027>:
      D.40030 = mini_get_debug_options ();
      D.40031 = D.40030->break_on_unverified;
      if (D.40031 != 0) goto <D.40032>; else goto unverified;
      <D.40032>:
      raise (5);
      <D.40025>:
      sp = sp + 18446744073709551608;
      D.39761 = ip + 4;
      if (D.39761 > end) goto <D.40033>; else goto <D.40034>;
      <D.40033>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.40035>; else goto <D.40036>;
      <D.40035>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.40037>; else goto <D.40038>;
      <D.40037>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40038>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40036>:
      D.40039 = mini_get_debug_options ();
      D.40040 = D.40039->break_on_unverified;
      if (D.40040 != 0) goto <D.40041>; else goto unverified;
      <D.40041>:
      raise (5);
      <D.40034>:
      D.31251 = ip + 2;
      D.39771 = MEM[(const guint16 *)D.31251];
      D.39772 = D.39771 >> 8;
      D.39773 = (int) D.39772;
      D.31251 = ip + 2;
      D.39771 = MEM[(const guint16 *)D.31251];
      D.39774 = (int) D.39771;
      D.39775 = D.39774 << 8;
      D.39776 = D.39775 & 65535;
      n = D.39773 | D.39776;
      D.30829 = header->num_locals;
      D.31194 = (unsigned int) D.30829;
      n.75 = (unsigned int) n;
      if (D.31194 <= n.75) goto <D.40042>; else goto <D.40043>;
      <D.40042>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.40044>; else goto <D.40045>;
      <D.40044>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.40046>; else goto <D.40047>;
      <D.40046>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40047>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40045>:
      D.40048 = mini_get_debug_options ();
      D.40049 = D.40048->break_on_unverified;
      if (D.40049 != 0) goto <D.40050>; else goto unverified;
      <D.40050>:
      raise (5);
      <D.40043>:
      if (dont_verify_stloc == 0) goto <D.40051>; else goto <D.40052>;
      <D.40051>:
      D.30817 = header->locals[n];
      D.31240 = *sp;
      D.40053 = target_type_is_incompatible (cfg, D.30817, D.31240);
      if (D.40053 != 0) goto <D.40054>; else goto <D.40055>;
      <D.40054>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.40056>; else goto <D.40057>;
      <D.40056>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.40058>; else goto <D.40059>;
      <D.40058>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40059>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40057>:
      D.40060 = mini_get_debug_options ();
      D.40061 = D.40060->break_on_unverified;
      if (D.40061 != 0) goto <D.40062>; else goto unverified;
      <D.40062>:
      raise (5);
      <D.40055>:
      <D.40052>:
      emit_stloc_ir (cfg, sp, header, n);
      ip = ip + 4;
      inline_costs = inline_costs + 1;
      goto <D.28088>;
      <D.28119>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.40063>; else goto <D.40064>;
      <D.40063>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.40065>; else goto <D.40066>;
      <D.40065>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.40067>; else goto <D.40068>;
      <D.40067>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40068>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40066>:
      D.40069 = mini_get_debug_options ();
      D.40070 = D.40069->break_on_unverified;
      if (D.40070 != 0) goto <D.40071>; else goto unverified;
      <D.40071>:
      raise (5);
      <D.40064>:
      sp = sp + 18446744073709551608;
      if (sp != stack_start) goto <D.40072>; else goto <D.40073>;
      <D.40072>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.40074>; else goto <D.40075>;
      <D.40074>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.40076>; else goto <D.40077>;
      <D.40076>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40077>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40075>:
      D.40078 = mini_get_debug_options ();
      D.40079 = D.40078->break_on_unverified;
      if (D.40079 != 0) goto <D.40080>; else goto unverified;
      <D.40080>:
      raise (5);
      <D.40073>:
      D.30211 = cfg->method;
      if (D.30211 != method) goto inline_failure; else goto <D.40081>;
      <D.40081>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 338;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      D.40082 = alloc_preg (cfg);
      D.40083 = (int) D.40082;
      ins->dreg = D.40083;
      D.31240 = *sp;
      D.31422 = D.31240->dreg;
      ins->sreg1 = D.31422;
      ins->type = 3;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      if (D.30490 != 0B) goto <D.40084>; else goto <D.40085>;
      <D.40084>:
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      D.30490->next = ins;
      bblock.106 = cfg->cbb;
      D.30490 = bblock.106->last_ins;
      ins->prev = D.30490;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      goto <D.40086>;
      <D.40085>:
      bblock.106 = cfg->cbb;
      bblock.106 = cfg->cbb;
      bblock.106->last_ins = ins;
      D.30490 = bblock.106->last_ins;
      bblock.106->code = D.30490;
      <D.40086>:
      D.30670 = cfg->flags;
      D.30671 = D.30670 | 1;
      cfg->flags = D.30671;
      if (init_locals != 0) goto <D.40087>; else goto <D.40088>;
      <D.40087>:
      D.31088 = ins->flags;
      D.40089 = D.31088 | 1;
      ins->flags = D.40089;
      <D.40088>:
      sp.317 = sp;
      sp = sp.317 + 8;
      *sp.317 = ins;
      ip = ip + 2;
      goto <D.28088>;
      <D.28120>:
      {
        struct MonoExceptionClause * clause;
        struct MonoExceptionClause * nearest;
        int cc;
        int nearest_num;

        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        if (D.31013 <= 7) goto <D.40091>; else goto <D.40092>;
        <D.40091>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.40093>; else goto <D.40094>;
        <D.40093>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.40095>; else goto <D.40096>;
        <D.40095>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.40096>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.40094>:
        D.40097 = mini_get_debug_options ();
        D.40098 = D.40097->break_on_unverified;
        if (D.40098 != 0) goto <D.40099>; else goto unverified;
        <D.40099>:
        raise (5);
        <D.40092>:
        sp = sp + 18446744073709551608;
        if (sp != stack_start) goto <D.40100>; else goto <D.40102>;
        <D.40102>:
        D.31240 = *sp;
        D.32922 = D.31240->type;
        if (D.32922 != 1) goto <D.40100>; else goto <D.40101>;
        <D.40100>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.40103>; else goto <D.40104>;
        <D.40103>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.40105>; else goto <D.40106>;
        <D.40105>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.40106>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.40104>:
        D.40107 = mini_get_debug_options ();
        D.40108 = D.40107->break_on_unverified;
        if (D.40108 != 0) goto <D.40109>; else goto unverified;
        <D.40109>:
        raise (5);
        <D.40101>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 737;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        ins->sreg1 = D.31422;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        if (D.30577 != 0B) goto <D.40110>; else goto <D.40111>;
        <D.40110>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        D.30577->next = ins;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        ins->prev = D.30577;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        goto <D.40112>;
        <D.40111>:
        bblock.64 = bblock;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        D.30577 = bblock.64->last_ins;
        bblock.64->code = D.30577;
        <D.40112>:
        start_new_bblock = 1;
        ip = ip + 2;
        nearest = 0B;
        nearest_num = 0;
        cc = 0;
        goto <D.28126>;
        <D.28125>:
        D.30369 = header->clauses;
        D.40113 = (long unsigned int) cc;
        D.40114 = D.40113 * 32;
        clause = D.30369 + D.40114;
        D.40117 = clause->flags;
        D.40118 = D.40117 & 1;
        if (D.40118 != 0) goto <D.40119>; else goto <D.40120>;
        <D.40119>:
        ip.69 = (long int) ip;
        D.30388 = header->code;
        D.30933 = (long int) D.30388;
        D.30934 = ip.69 - D.30933;
        D.40121 = clause->data.filter_offset;
        D.40122 = (long int) D.40121;
        if (D.30934 > D.40122) goto <D.40123>; else goto <D.40124>;
        <D.40123>:
        ip.69 = (long int) ip;
        D.30388 = header->code;
        D.30933 = (long int) D.30388;
        D.30934 = ip.69 - D.30933;
        D.40125 = clause->handler_offset;
        D.40126 = (long int) D.40125;
        if (D.30934 <= D.40126) goto <D.40127>; else goto <D.40128>;
        <D.40127>:
        if (nearest == 0B) goto <D.40115>; else goto <D.40129>;
        <D.40129>:
        D.40121 = clause->data.filter_offset;
        D.40130 = nearest->data.filter_offset;
        if (D.40121 < D.40130) goto <D.40115>; else goto <D.40116>;
        <D.40115>:
        nearest = clause;
        nearest_num = cc;
        <D.40116>:
        <D.40128>:
        <D.40124>:
        <D.40120>:
        cc = cc + 1;
        <D.28126>:
        D.30555 = header->num_clauses;
        D.30556 = (int) D.30555;
        if (D.30556 > cc) goto <D.28125>; else goto <D.28127>;
        <D.28127>:
        D.40131 = nearest == 0B;
        D.40132 = (long int) D.40131;
        D.40133 = __builtin_expect (D.40132, 0);
        if (D.40133 != 0) goto <D.40134>; else goto <D.40135>;
        <D.40134>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11690, "nearest");
        <D.40135>:
        ip.69 = (long int) ip;
        D.30388 = header->code;
        D.30933 = (long int) D.30388;
        D.30934 = ip.69 - D.30933;
        D.40136 = nearest->handler_offset;
        D.40137 = (long int) D.40136;
        if (D.30934 != D.40137) goto <D.40138>; else goto <D.40139>;
        <D.40138>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.40140>; else goto <D.40141>;
        <D.40140>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.40142>; else goto <D.40143>;
        <D.40142>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.40143>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.40141>:
        D.40144 = mini_get_debug_options ();
        D.40145 = D.40144->break_on_unverified;
        if (D.40145 != 0) goto <D.40146>; else goto unverified;
        <D.40146>:
        raise (5);
        <D.40139>:
        goto <D.28088>;
      }
      <D.28128>:
      ins_flag = ins_flag | 8;
      D.40147 = ip + 3;
      if (D.40147 > end) goto <D.40148>; else goto <D.40149>;
      <D.40148>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.40150>; else goto <D.40151>;
      <D.40150>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.40152>; else goto <D.40153>;
      <D.40152>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40153>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40151>:
      D.40154 = mini_get_debug_options ();
      D.40155 = D.40154->break_on_unverified;
      if (D.40155 != 0) goto <D.40156>; else goto unverified;
      <D.40156>:
      raise (5);
      <D.40149>:
      ip = ip + 3;
      goto <D.28088>;
      <D.28129>:
      ins_flag = ins_flag | 4;
      ip = ip + 2;
      goto <D.28088>;
      <D.28130>:
      ins_flag = ins_flag | 4;
      D.30670 = cfg->flags;
      D.40157 = D.30670 | 16;
      cfg->flags = D.40157;
      inline_costs = inline_costs + 100000;
      ip = ip + 2;
      goto <D.28088>;
      <D.28131>:
      sp.71 = (long int) sp;
      stack_start.72 = (long int) stack_start;
      D.31013 = sp.71 - stack_start.72;
      if (D.31013 <= 7) goto <D.40158>; else goto <D.40159>;
      <D.40158>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.40160>; else goto <D.40161>;
      <D.40160>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.40162>; else goto <D.40163>;
      <D.40162>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40163>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40161>:
      D.40164 = mini_get_debug_options ();
      D.40165 = D.40164->break_on_unverified;
      if (D.40165 != 0) goto <D.40166>; else goto unverified;
      <D.40166>:
      raise (5);
      <D.40159>:
      sp = sp + 18446744073709551608;
      D.34754 = ip + 6;
      if (D.34754 > end) goto <D.40167>; else goto <D.40168>;
      <D.40167>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.40169>; else goto <D.40170>;
      <D.40169>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.40171>; else goto <D.40172>;
      <D.40171>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40172>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40170>:
      D.40173 = mini_get_debug_options ();
      D.40174 = D.40173->break_on_unverified;
      if (D.40174 != 0) goto <D.40175>; else goto unverified;
      <D.40175>:
      raise (5);
      <D.40168>:
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38573 = D.38572 << 24;
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38574 = D.38572 >> 8;
      D.38575 = D.38574 & 65280;
      D.38576 = D.38573 | D.38575;
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38577 = D.38572 << 8;
      D.38578 = D.38577 & 16711680;
      D.38579 = D.38576 | D.38578;
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38580 = D.38572 >> 24;
      token = D.38579 | D.38580;
      klass.318 = mini_get_class (method, token, generic_context);
      klass = klass.318;
      klass.144 = klass;
      if (klass.144 == 0B) goto <D.40177>; else goto <D.40179>;
      <D.40179>:
      klass.144 = klass;
      D.34697 = klass.144->exception_type;
      if (D.34697 != 0) goto <D.40177>; else goto <D.40178>;
      <D.40177>:
      klass.144 = klass;
      cfg->exception_ptr = klass.144;
      D.40180 = mini_get_debug_options ();
      D.40181 = D.40180->break_on_unverified;
      if (D.40181 != 0) goto <D.40182>; else goto load_error;
      <D.40182>:
      raise (5);
      <D.40178>:
      klass.144 = klass;
      D.40183 = generic_class_is_reference_type (cfg, klass.144);
      if (D.40183 != 0) goto <D.40184>; else goto <D.40185>;
      <D.40184>:
      {
        struct MonoInst * inst;

        D.30241 = cfg->mempool;
        inst = mono_mempool_alloc (D.30241, 80);
        inst->data.op[1].const_val = 0;
        D.40186 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.40186;
        inst->prev = 0B;
        D.40187 = inst->prev;
        inst->next = D.40187;
        inst->opcode = 381;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.40188 = inst->sreg3;
        inst->sreg2 = D.40188;
        D.40189 = inst->sreg2;
        inst->sreg1 = D.40189;
        D.30461 = cfg->ip;
        inst->cil_code = D.30461;
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        inst->dreg = D.31422;
        inst->data.op[0].const_val = 0;
        inst->data.op[1].const_val = 0;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.40190>; else goto <D.40191>;
        <D.40190>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = inst;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        inst->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = inst;
        goto <D.40192>;
        <D.40191>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = inst;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.40192>:
      }
      goto <D.40193>;
      <D.40185>:
      D.31240 = *sp;
      klass.144 = klass;
      mini_emit_initobj (cfg, D.31240, 0B, klass.144);
      <D.40193>:
      ip = ip + 6;
      inline_costs = inline_costs + 1;
      goto <D.28088>;
      <D.28133>:
      D.34754 = ip + 6;
      if (D.34754 > end) goto <D.40194>; else goto <D.40195>;
      <D.40194>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.40196>; else goto <D.40197>;
      <D.40196>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.40198>; else goto <D.40199>;
      <D.40198>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40199>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40197>:
      D.40200 = mini_get_debug_options ();
      D.40201 = D.40200->break_on_unverified;
      if (D.40201 != 0) goto <D.40202>; else goto unverified;
      <D.40202>:
      raise (5);
      <D.40195>:
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38573 = D.38572 << 24;
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38574 = D.38572 >> 8;
      D.38575 = D.38574 & 65280;
      D.38576 = D.38573 | D.38575;
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38577 = D.38572 << 8;
      D.38578 = D.38577 & 16711680;
      D.38579 = D.38576 | D.38578;
      D.31251 = ip + 2;
      D.38572 = MEM[(const guint32 *)D.31251];
      D.38580 = D.38572 >> 24;
      token = D.38579 | D.38580;
      constrained_call = mini_get_class (method, token, generic_context);
      if (constrained_call == 0B) goto <D.40203>; else goto <D.40205>;
      <D.40205>:
      D.32541 = constrained_call->exception_type;
      if (D.32541 != 0) goto <D.40203>; else goto <D.40204>;
      <D.40203>:
      cfg->exception_ptr = constrained_call;
      D.40206 = mini_get_debug_options ();
      D.40207 = D.40206->break_on_unverified;
      if (D.40207 != 0) goto <D.40208>; else goto load_error;
      <D.40208>:
      raise (5);
      <D.40204>:
      ip = ip + 6;
      goto <D.28088>;
      <D.28134>:
      <D.28135>:
      {
        struct MonoInst * iargs[3];

        try
          {
            sp.71 = (long int) sp;
            stack_start.72 = (long int) stack_start;
            D.31013 = sp.71 - stack_start.72;
            if (D.31013 <= 23) goto <D.40209>; else goto <D.40210>;
            <D.40209>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.40211>; else goto <D.40212>;
            <D.40211>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.40213>; else goto <D.40214>;
            <D.40213>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.40214>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.40212>:
            D.40215 = mini_get_debug_options ();
            D.40216 = D.40215->break_on_unverified;
            if (D.40216 != 0) goto <D.40217>; else goto unverified;
            <D.40217>:
            raise (5);
            <D.40210>:
            sp = sp + 18446744073709551592;
            D.31270 = ip + 1;
            D.31271 = *D.31270;
            if (D.31271 == 23) goto <D.40220>; else goto <D.40218>;
            <D.40220>:
            D.30632 = cfg->opt;
            D.32600 = D.30632 & 2048;
            if (D.32600 != 0) goto <D.40221>; else goto <D.40218>;
            <D.40221>:
            D.40222 = sp + 16;
            D.40223 = *D.40222;
            D.40224 = D.40223->opcode;
            if (D.40224 == 362) goto <D.40225>; else goto <D.40218>;
            <D.40225>:
            D.40222 = sp + 16;
            D.40223 = *D.40222;
            D.40226 = D.40223->data.op[0].const_val;
            n = (int) D.40226;
            n.75 = (unsigned int) n;
            if (n.75 <= 40) goto <D.40227>; else goto <D.40218>;
            <D.40227>:
            D.31240 = *sp;
            D.31422 = D.31240->dreg;
            D.32378 = sp + 8;
            D.32379 = *D.32378;
            D.32380 = D.32379->dreg;
            D.40222 = sp + 16;
            D.40223 = *D.40222;
            D.40226 = D.40223->data.op[0].const_val;
            D.40228 = (int) D.40226;
            mini_emit_memcpy (cfg, D.31422, 0, D.32380, 0, D.40228, 0);
            goto <D.40219>;
            <D.40218>:
            D.31270 = ip + 1;
            D.31271 = *D.31270;
            if (D.31271 == 24) goto <D.40231>; else goto <D.40229>;
            <D.40231>:
            D.30632 = cfg->opt;
            D.32600 = D.30632 & 2048;
            if (D.32600 != 0) goto <D.40232>; else goto <D.40229>;
            <D.40232>:
            D.40222 = sp + 16;
            D.40223 = *D.40222;
            D.40224 = D.40223->opcode;
            if (D.40224 == 362) goto <D.40233>; else goto <D.40229>;
            <D.40233>:
            D.40222 = sp + 16;
            D.40223 = *D.40222;
            D.40226 = D.40223->data.op[0].const_val;
            n = (int) D.40226;
            n.75 = (unsigned int) n;
            if (n.75 <= 40) goto <D.40234>; else goto <D.40229>;
            <D.40234>:
            D.32378 = sp + 8;
            D.32379 = *D.32378;
            D.34346 = D.32379->opcode;
            if (D.34346 == 362) goto <D.40235>; else goto <D.40229>;
            <D.40235>:
            D.32378 = sp + 8;
            D.32379 = *D.32378;
            D.34371 = D.32379->data.op[0].const_val;
            if (D.34371 == 0) goto <D.40236>; else goto <D.40229>;
            <D.40236>:
            D.31240 = *sp;
            D.31422 = D.31240->dreg;
            D.40222 = sp + 16;
            D.40223 = *D.40222;
            D.40226 = D.40223->data.op[0].const_val;
            D.40228 = (int) D.40226;
            D.32378 = sp + 8;
            D.32379 = *D.32378;
            D.34371 = D.32379->data.op[0].const_val;
            D.40237 = (int) D.34371;
            mini_emit_memset (cfg, D.31422, 0, D.40228, D.40237, 0);
            goto <D.40230>;
            <D.40229>:
            D.31240 = *sp;
            iargs[0] = D.31240;
            D.35164 = MEM[(struct MonoInst * *)sp + 8B];
            iargs[1] = D.35164;
            D.40238 = MEM[(struct MonoInst * *)sp + 16B];
            iargs[2] = D.40238;
            D.31270 = ip + 1;
            D.31271 = *D.31270;
            if (D.31271 == 23) goto <D.40239>; else goto <D.40240>;
            <D.40239>:
            {
              struct MonoMethod * memcpy_method;

              memcpy_method = get_memcpy_method ();
              mono_emit_method_call (cfg, memcpy_method, &iargs, 0B);
            }
            goto <D.40241>;
            <D.40240>:
            {
              struct MonoMethod * memset_method;

              memset_method = get_memset_method ();
              mono_emit_method_call (cfg, memset_method, &iargs, 0B);
            }
            <D.40241>:
            <D.40230>:
            <D.40219>:
            ip = ip + 2;
            inline_costs = inline_costs + 1;
            goto <D.28088>;
          }
        finally
          {
            iargs = {CLOBBER};
          }
      }
      <D.28139>:
      D.40147 = ip + 3;
      if (D.40147 > end) goto <D.40242>; else goto <D.40243>;
      <D.40242>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.40244>; else goto <D.40245>;
      <D.40244>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.40246>; else goto <D.40247>;
      <D.40246>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40247>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40245>:
      D.40248 = mini_get_debug_options ();
      D.40249 = D.40248->break_on_unverified;
      if (D.40249 != 0) goto <D.40250>; else goto unverified;
      <D.40250>:
      raise (5);
      <D.40243>:
      D.31251 = ip + 2;
      D.40251 = *D.31251;
      D.40252 = (int) D.40251;
      D.40253 = D.40252 & 1;
      if (D.40253 != 0) goto <D.40254>; else goto <D.40255>;
      <D.40254>:
      ins_flag = ins_flag | 4;
      <D.40255>:
      D.31251 = ip + 2;
      D.40251 = *D.31251;
      D.40252 = (int) D.40251;
      D.40256 = D.40252 & 2;
      if (D.40256 != 0) goto <D.40257>; else goto <D.40258>;
      <D.40257>:
      ins_flag = ins_flag | 16;
      <D.40258>:
      ip = ip + 3;
      goto <D.28088>;
      <D.28140>:
      {
        struct MonoInst * load;
        int handler_offset;

        handler_offset = -1;
        i = 0;
        goto <D.28146>;
        <D.28145>:
        {
          struct MonoExceptionClause * clause;

          D.30369 = header->clauses;
          D.30370 = (long unsigned int) i;
          D.30371 = D.30370 * 32;
          clause = D.30369 + D.30371;
          D.40259 = clause->handler_offset;
          D.40260 = (long int) D.40259;
          ip.69 = (long int) ip;
          D.30388 = header->code;
          D.30933 = (long int) D.30388;
          D.30934 = ip.69 - D.30933;
          if (D.40260 <= D.30934) goto <D.40261>; else goto <D.40262>;
          <D.40261>:
          ip.69 = (long int) ip;
          D.30388 = header->code;
          D.30933 = (long int) D.30388;
          D.30934 = ip.69 - D.30933;
          D.40259 = clause->handler_offset;
          D.40263 = clause->handler_len;
          D.40264 = D.40259 + D.40263;
          D.40265 = (long int) D.40264;
          if (D.30934 < D.40265) goto <D.40266>; else goto <D.40267>;
          <D.40266>:
          D.40268 = clause->flags;
          D.40269 = D.40268 & 2;
          if (D.40269 == 0) goto <D.40270>; else goto <D.40271>;
          <D.40270>:
          D.40259 = clause->handler_offset;
          handler_offset = (int) D.40259;
          goto <D.28144>;
          <D.40271>:
          <D.40267>:
          <D.40262>:
        }
        i = i + 1;
        <D.28146>:
        D.30555 = header->num_clauses;
        D.30556 = (int) D.30555;
        if (D.30556 > i) goto <D.28145>; else goto <D.28144>;
        <D.28144>:
        bblock.64 = bblock;
        bblock.64 = bblock;
        D.40272 = bblock.64->flags;
        D.40273 = D.40272 | 8;
        bblock.64->flags = D.40273;
        D.40274 = handler_offset == -1;
        D.40275 = (long int) D.40274;
        D.40276 = __builtin_expect (D.40275, 0);
        if (D.40276 != 0) goto <D.40277>; else goto <D.40278>;
        <D.40277>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11786, "handler_offset != -1");
        <D.40278>:
        D.30241 = cfg->mempool;
        load = mono_mempool_alloc (D.30241, 80);
        load->data.op[1].const_val = 0;
        D.40279 = load->data.op[1].const_val;
        load->data.op[0].const_val = D.40279;
        load->prev = 0B;
        D.40280 = load->prev;
        load->next = D.40280;
        load->opcode = 424;
        load->flags = 0;
        load->type = 0;
        load->dreg = -1;
        load->sreg3 = -1;
        D.40281 = load->sreg3;
        load->sreg2 = D.40281;
        D.40282 = load->sreg2;
        load->sreg1 = D.40282;
        D.30461 = cfg->ip;
        load->cil_code = D.30461;
        D.30978 = cfg->varinfo;
        D.40283 = mono_find_exvar_for_offset (cfg, handler_offset);
        D.40284 = D.40283->data.op[0].const_val;
        D.40285 = (long unsigned int) D.40284;
        D.40286 = D.40285 * 8;
        D.40287 = D.30978 + D.40286;
        D.40288 = *D.40287;
        D.40289 = D.40288->data.op[1].vtype;
        D.40290 = mono_type_to_regmove (cfg, D.40289);
        D.40291 = (short unsigned int) D.40290;
        load->opcode = D.40291;
        D.30978 = cfg->varinfo;
        D.40292 = mono_find_exvar_for_offset (cfg, handler_offset);
        D.40293 = D.40292->data.op[0].const_val;
        D.40294 = (long unsigned int) D.40293;
        D.40295 = D.40294 * 8;
        D.40296 = D.30978 + D.40295;
        D.40297 = *D.40296;
        D.40298 = D.40297->data.op[1].vtype;
        type_to_eval_stack_type (cfg, D.40298, load);
        D.30978 = cfg->varinfo;
        D.40299 = mono_find_exvar_for_offset (cfg, handler_offset);
        D.40300 = D.40299->data.op[0].const_val;
        D.40301 = (long unsigned int) D.40300;
        D.40302 = D.40301 * 8;
        D.40303 = D.30978 + D.40302;
        D.40304 = *D.40303;
        D.40305 = D.40304->klass;
        load->klass = D.40305;
        D.30978 = cfg->varinfo;
        D.40306 = mono_find_exvar_for_offset (cfg, handler_offset);
        D.40307 = D.40306->data.op[0].const_val;
        D.40308 = (long unsigned int) D.40307;
        D.40309 = D.40308 * 8;
        D.40310 = D.30978 + D.40309;
        D.40311 = *D.40310;
        D.40312 = D.40311->dreg;
        load->sreg1 = D.40312;
        D.40313 = load->type;
        D.40314 = (<unnamed type>) D.40313;
        D.40315 = alloc_dreg (cfg, D.40314);
        D.40316 = (int) D.40315;
        load->dreg = D.40316;
        D.40317 = load->opcode;
        if (D.40317 == 427) goto <D.40318>; else goto <D.40319>;
        <D.40318>:
        D.30978 = cfg->varinfo;
        D.40320 = mono_find_exvar_for_offset (cfg, handler_offset);
        D.40321 = D.40320->data.op[0].const_val;
        D.40322 = (long unsigned int) D.40321;
        D.40323 = D.40322 * 8;
        D.40324 = D.30978 + D.40323;
        D.40325 = *D.40324;
        D.40326 = D.40325->data.op[1].vtype;
        D.40327 = mono_class_from_mono_type (D.40326);
        load->klass = D.40327;
        <D.40319>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.40328>; else goto <D.40329>;
        <D.40328>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = load;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        load->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = load;
        goto <D.40330>;
        <D.40329>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = load;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.40330>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 372;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        D.40331 = load->dreg;
        ins->sreg1 = D.40331;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        if (D.30577 != 0B) goto <D.40332>; else goto <D.40333>;
        <D.40332>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        D.30577->next = ins;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        ins->prev = D.30577;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        goto <D.40334>;
        <D.40333>:
        bblock.64 = bblock;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        D.30577 = bblock.64->last_ins;
        bblock.64->code = D.30577;
        <D.40334>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        ins->opcode = 798;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        if (D.30577 != 0B) goto <D.40335>; else goto <D.40336>;
        <D.40335>:
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        D.30577->next = ins;
        bblock.64 = bblock;
        D.30577 = bblock.64->last_ins;
        ins->prev = D.30577;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        goto <D.40337>;
        <D.40336>:
        bblock.64 = bblock;
        bblock.64 = bblock;
        bblock.64->last_ins = ins;
        D.30577 = bblock.64->last_ins;
        bblock.64->code = D.30577;
        <D.40337>:
        sp = stack_start;
        bblock.64 = bblock;
        link_bblock (cfg, bblock.64, end_bblock);
        start_new_bblock = 1;
        ip = ip + 2;
        goto <D.28088>;
      }
      <D.28147>:
      {
        guint32 val;
        int ialign;

        try
          {
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.40338>; else goto <D.40339>;
            <D.40338>:
            D.30178 = method->klass;
            D.31934 = D.30178->name_space;
            D.30178 = method->klass;
            D.31935 = D.30178->name;
            D.31936 = method->name;
            D.31937 = method->signature;
            D.31938 = D.31937->param_count;
            D.31939 = (int) D.31938;
            D.31121 = *ip;
            D.31122 = (int) D.31121;
            D.40340 = mono_opcode_name (D.31122);
            D.40341 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.31934, D.31935, D.31936, D.31939, D.40340, "method-to-ir.c", 11806);
            cfg->exception_message = D.40341;
            D.30322 = cfg->verbose_level;
            if (D.30322 > 1) goto <D.40342>; else goto <D.40343>;
            <D.40342>:
            D.31944 = cfg->exception_message;
            printf ("%s\n", D.31944);
            <D.40343>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.40339>:
            sp.71 = (long int) sp;
            stack_start.72 = (long int) stack_start;
            D.31013 = sp.71 - stack_start.72;
            D.31014 = D.31013 /[ex] 8;
            D.30924 = header->max_stack;
            D.31146 = (long int) D.30924;
            if (D.31014 >= D.31146) goto <D.40344>; else goto <D.40345>;
            <D.40344>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.40346>; else goto <D.40347>;
            <D.40346>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.40348>; else goto <D.40349>;
            <D.40348>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.40349>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.40347>:
            D.40350 = mini_get_debug_options ();
            D.40351 = D.40350->break_on_unverified;
            if (D.40351 != 0) goto <D.40352>; else goto unverified;
            <D.40352>:
            raise (5);
            <D.40345>:
            D.34754 = ip + 6;
            if (D.34754 > end) goto <D.40353>; else goto <D.40354>;
            <D.40353>:
            D.30389 = cfg->gsharedvt;
            if (D.30389 != 0) goto <D.40355>; else goto <D.40356>;
            <D.40355>:
            D.30322 = cfg->verbose_level;
            if (D.30322 > 2) goto <D.40357>; else goto <D.40358>;
            <D.40357>:
            printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
            <D.40358>:
            mono_cfg_set_exception (cfg, 11);
            goto exception_exit;
            <D.40356>:
            D.40359 = mini_get_debug_options ();
            D.40360 = D.40359->break_on_unverified;
            if (D.40360 != 0) goto <D.40361>; else goto unverified;
            <D.40361>:
            raise (5);
            <D.40354>:
            D.31251 = ip + 2;
            D.38572 = MEM[(const guint32 *)D.31251];
            D.38573 = D.38572 << 24;
            D.31251 = ip + 2;
            D.38572 = MEM[(const guint32 *)D.31251];
            D.38574 = D.38572 >> 8;
            D.38575 = D.38574 & 65280;
            D.38576 = D.38573 | D.38575;
            D.31251 = ip + 2;
            D.38572 = MEM[(const guint32 *)D.31251];
            D.38577 = D.38572 << 8;
            D.38578 = D.38577 & 16711680;
            D.38579 = D.38576 | D.38578;
            D.31251 = ip + 2;
            D.38572 = MEM[(const guint32 *)D.31251];
            D.38580 = D.38572 >> 24;
            token = D.38579 | D.38580;
            D.40364 = token >> 24;
            if (D.40364 == 27) goto <D.40365>; else goto <D.40362>;
            <D.40365>:
            D.30178 = method->klass;
            D.30179 = D.30178->image;
            D.40366 = BIT_FIELD_REF <*D.30179, 64, 192>;
            D.40367 = D.40366 & 268435456;
            if (D.40367 == 0) goto <D.40368>; else goto <D.40362>;
            <D.40368>:
            if (generic_context == 0B) goto <D.40369>; else goto <D.40362>;
            <D.40369>:
            {
              struct MonoType * type;

              type = mono_type_create_from_typespec (image, token);
              D.40370 = mono_type_size (type, &ialign);
              val = (guint32) D.40370;
            }
            goto <D.40363>;
            <D.40362>:
            {
              struct MonoClass * klass;

              klass = mono_class_get_full (image, token, generic_context);
              if (klass == 0B) goto <D.40371>; else goto <D.40373>;
              <D.40373>:
              D.40374 = klass->exception_type;
              if (D.40374 != 0) goto <D.40371>; else goto <D.40372>;
              <D.40371>:
              cfg->exception_ptr = klass;
              D.40375 = mini_get_debug_options ();
              D.40376 = D.40375->break_on_unverified;
              if (D.40376 != 0) goto <D.40377>; else goto load_error;
              <D.40377>:
              raise (5);
              <D.40372>:
              mono_class_init (klass);
              D.40378 = &klass->byval_arg;
              D.40379 = mono_type_size (D.40378, &ialign);
              val = (guint32) D.40379;
            }
            <D.40363>:
            D.30241 = cfg->mempool;
            ins = mono_mempool_alloc (D.30241, 80);
            ins->data.op[1].const_val = 0;
            D.30457 = ins->data.op[1].const_val;
            ins->data.op[0].const_val = D.30457;
            ins->prev = 0B;
            D.30458 = ins->prev;
            ins->next = D.30458;
            ins->opcode = 362;
            ins->flags = 0;
            ins->type = 0;
            ins->dreg = -1;
            ins->sreg3 = -1;
            D.30459 = ins->sreg3;
            ins->sreg2 = D.30459;
            D.30460 = ins->sreg2;
            ins->sreg1 = D.30460;
            D.30461 = cfg->ip;
            ins->cil_code = D.30461;
            D.40380 = (long int) val;
            ins->data.op[0].const_val = D.40380;
            ins->type = 1;
            D.40381 = alloc_dreg (cfg, 1);
            D.40382 = (int) D.40381;
            ins->dreg = D.40382;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            if (D.30490 != 0B) goto <D.40383>; else goto <D.40384>;
            <D.40383>:
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            D.30490->next = ins;
            bblock.106 = cfg->cbb;
            D.30490 = bblock.106->last_ins;
            ins->prev = D.30490;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            goto <D.40385>;
            <D.40384>:
            bblock.106 = cfg->cbb;
            bblock.106 = cfg->cbb;
            bblock.106->last_ins = ins;
            D.30490 = bblock.106->last_ins;
            bblock.106->code = D.30490;
            <D.40385>:
            sp.319 = sp;
            sp = sp.319 + 8;
            *sp.319 = ins;
            ip = ip + 6;
            goto <D.28088>;
          }
        finally
          {
            ialign = {CLOBBER};
          }
      }
      <D.28152>:
      {
        struct MonoInst * src_var;
        struct MonoInst * src;

        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.40387>; else goto <D.40388>;
        <D.40387>:
        D.30178 = method->klass;
        D.31934 = D.30178->name_space;
        D.30178 = method->klass;
        D.31935 = D.30178->name;
        D.31936 = method->name;
        D.31937 = method->signature;
        D.31938 = D.31937->param_count;
        D.31939 = (int) D.31938;
        D.31121 = *ip;
        D.31122 = (int) D.31121;
        D.40389 = mono_opcode_name (D.31122);
        D.40390 = monoeg_g_strdup_printf ("gsharedvt failed for method %s.%s.%s/%d opcode %s %s:%d", D.31934, D.31935, D.31936, D.31939, D.40389, "method-to-ir.c", 11828);
        cfg->exception_message = D.40390;
        D.30322 = cfg->verbose_level;
        if (D.30322 > 1) goto <D.40391>; else goto <D.40392>;
        <D.40391>:
        D.31944 = cfg->exception_message;
        printf ("%s\n", D.31944);
        <D.40392>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.40388>:
        sp.71 = (long int) sp;
        stack_start.72 = (long int) stack_start;
        D.31013 = sp.71 - stack_start.72;
        if (D.31013 <= 7) goto <D.40393>; else goto <D.40394>;
        <D.40393>:
        D.30389 = cfg->gsharedvt;
        if (D.30389 != 0) goto <D.40395>; else goto <D.40396>;
        <D.40395>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.40397>; else goto <D.40398>;
        <D.40397>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.40398>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.40396>:
        D.40399 = mini_get_debug_options ();
        D.40400 = D.40399->break_on_unverified;
        if (D.40400 != 0) goto <D.40401>; else goto unverified;
        <D.40401>:
        raise (5);
        <D.40394>:
        sp = sp + 18446744073709551608;
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        D.36366 = (unsigned int) D.31422;
        D.31341 = cfg->vreg_to_inst_len;
        if (D.36366 < D.31341) goto <D.40403>; else goto <D.40404>;
        <D.40403>:
        D.31344 = cfg->vreg_to_inst;
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        D.36369 = (long unsigned int) D.31422;
        D.36370 = D.36369 * 8;
        D.36371 = D.31344 + D.36370;
        iftmp.320 = *D.36371;
        goto <D.40405>;
        <D.40404>:
        iftmp.320 = 0B;
        <D.40405>:
        src_var = iftmp.320;
        if (src_var == 0B) goto <D.40406>; else goto <D.40407>;
        <D.40406>:
        D.37710 = mono_defaults.typed_reference_class;
        D.37711 = &D.37710->byval_arg;
        D.31240 = *sp;
        D.31422 = D.31240->dreg;
        src_var = mono_compile_create_var_for_vreg (cfg, D.37711, 329, D.31422);
        <D.40407>:
        D.30241 = cfg->mempool;
        src = mono_mempool_alloc (D.30241, 80);
        src->data.op[1].const_val = 0;
        D.40408 = src->data.op[1].const_val;
        src->data.op[0].const_val = D.40408;
        src->prev = 0B;
        D.40409 = src->prev;
        src->next = D.40409;
        src->opcode = 314;
        src->flags = 0;
        src->type = 0;
        src->dreg = -1;
        src->sreg3 = -1;
        D.40410 = src->sreg3;
        src->sreg2 = D.40410;
        D.40411 = src->sreg2;
        src->sreg1 = D.40411;
        D.30461 = cfg->ip;
        src->cil_code = D.30461;
        src->data.op[0].p = src_var;
        D.40412 = src_var->flags;
        D.40413 = D.40412 | 16;
        src_var->flags = D.40413;
        src->type = 5;
        D.40414 = src_var->klass;
        src->klass = D.40414;
        D.40415 = alloc_dreg (cfg, 5);
        D.40416 = (int) D.40415;
        src->dreg = D.40416;
        cfg->has_indirection = 1;
        D.30389 = cfg->gsharedvt;
        D.31326 = D.30389 != 0;
        D.31327 = (long int) D.31326;
        D.31328 = __builtin_expect (D.31327, 0);
        if (D.31328 != 0) goto <D.40417>; else goto <D.40418>;
        <D.40417>:
        D.40419 = src_var->data.op[1].vtype;
        D.40420 = mini_is_gsharedvt_variable_type (cfg, D.40419);
        if (D.40420 != 0) goto <D.40421>; else goto <D.40422>;
        <D.40421>:
        handle_gsharedvt_ldaddr (cfg);
        <D.40422>:
        <D.40418>:
        if (0 != 0) goto <D.40423>; else goto <D.40424>;
        <D.40423>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.40426 = src_var->dreg;
          D.40427 = D.40426 + 1;
          D.40428 = (unsigned int) D.40427;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.40428 < D.31341) goto <D.40429>; else goto <D.40430>;
          <D.40429>:
          D.31344 = cfg->vreg_to_inst;
          D.40426 = src_var->dreg;
          D.40431 = (sizetype) D.40426;
          D.40432 = D.40431 + 1;
          D.40433 = D.40432 * 8;
          D.40434 = D.31344 + D.40433;
          iftmp.321 = *D.40434;
          goto <D.40435>;
          <D.40430>:
          iftmp.321 = 0B;
          <D.40435>:
          var1 = iftmp.321;
          D.40426 = src_var->dreg;
          D.40437 = D.40426 + 2;
          D.40438 = (unsigned int) D.40437;
          D.31341 = cfg->vreg_to_inst_len;
          if (D.40438 < D.31341) goto <D.40439>; else goto <D.40440>;
          <D.40439>:
          D.31344 = cfg->vreg_to_inst;
          D.40426 = src_var->dreg;
          D.40431 = (sizetype) D.40426;
          D.40441 = D.40431 + 2;
          D.40442 = D.40441 * 8;
          D.40443 = D.31344 + D.40442;
          iftmp.322 = *D.40443;
          goto <D.40444>;
          <D.40440>:
          iftmp.322 = 0B;
          <D.40444>:
          var2 = iftmp.322;
          D.40445 = var1 == 0B;
          D.40446 = (long int) D.40445;
          D.40447 = __builtin_expect (D.40446, 0);
          if (D.40447 != 0) goto <D.40448>; else goto <D.40449>;
          <D.40448>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11837, "var1");
          <D.40449>:
          D.40450 = var2 == 0B;
          D.40451 = (long int) D.40450;
          D.40452 = __builtin_expect (D.40451, 0);
          if (D.40452 != 0) goto <D.40453>; else goto <D.40454>;
          <D.40453>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 11837, "var2");
          <D.40454>:
          D.40455 = var1->flags;
          D.40456 = D.40455 | 16;
          var1->flags = D.40456;
          D.40457 = var2->flags;
          D.40458 = D.40457 | 16;
          var2->flags = D.40458;
        }
        <D.40424>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.40459>; else goto <D.40460>;
        <D.40459>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = src;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        src->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = src;
        goto <D.40461>;
        <D.40460>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = src;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.40461>:
        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.30457 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.30457;
        ins->prev = 0B;
        D.30458 = ins->prev;
        ins->next = D.30458;
        D.38009 = mono_defaults.typehandle_class;
        D.40462 = &D.38009->byval_arg;
        D.40463 = mono_type_to_load_membase (cfg, D.40462);
        D.40464 = (short unsigned int) D.40463;
        ins->opcode = D.40464;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.30459 = ins->sreg3;
        ins->sreg2 = D.30459;
        D.30460 = ins->sreg2;
        ins->sreg1 = D.30460;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        ins->dreg = 0;
        D.40465 = src->dreg;
        ins->sreg1 = D.40465;
        ins->data.op[0].const_val = 0;
        ins->type = 1;
        D.38009 = mono_defaults.typehandle_class;
        D.40462 = &D.38009->byval_arg;
        type_to_eval_stack_type (cfg, D.40462, ins);
        D.30988 = ins->type;
        D.30989 = (<unnamed type>) D.30988;
        D.40466 = alloc_dreg (cfg, D.30989);
        D.40467 = (int) D.40466;
        ins->dreg = D.40467;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.40468>; else goto <D.40469>;
        <D.40468>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = ins;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        ins->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        goto <D.40470>;
        <D.40469>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = ins;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.40470>:
        sp.323 = sp;
        sp = sp.323 + 8;
        *sp.323 = ins;
        ip = ip + 2;
        goto <D.28088>;
      }
      <D.28157>:
      readonly = 1;
      ip = ip + 2;
      goto <D.28088>;
      <D.28158>:
      <D.28159>:
      <D.28160>:
      <D.28161>:
      <D.28162>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.40472>; else goto <D.40473>;
      <D.40472>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.40474>; else goto <D.40475>;
      <D.40474>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40475>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40473>:
      D.40476 = mini_get_debug_options ();
      D.40477 = D.40476->break_on_unverified;
      if (D.40477 != 0) goto <D.40478>; else goto unverified;
      <D.40478>:
      raise (5);
      <D.28163>:
      D.31270 = ip + 1;
      D.31271 = *D.31270;
      D.31579 = (int) D.31271;
      monoeg_g_log (0B, 16, "opcode 0xfe 0x%02x not handled", D.31579);
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.40479>; else goto <D.40480>;
      <D.40479>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.40481>; else goto <D.40482>;
      <D.40481>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40482>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40480>:
      D.40483 = mini_get_debug_options ();
      D.40484 = D.40483->break_on_unverified;
      if (D.40484 != 0) goto <D.40485>; else goto unverified;
      <D.40485>:
      raise (5);
      <D.28088>:
      goto <D.27394>;
      <D.28164>:
      <D.28165>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.40486>; else goto <D.40487>;
      <D.40486>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.40488>; else goto <D.40489>;
      <D.40488>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40489>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40487>:
      D.40490 = mini_get_debug_options ();
      D.40491 = D.40490->break_on_unverified;
      if (D.40491 != 0) goto <D.40492>; else goto unverified;
      <D.40492>:
      raise (5);
      <D.28166>:
      D.31121 = *ip;
      D.31122 = (int) D.31121;
      monoeg_g_log (0B, 16, "opcode 0x%02x not handled", D.31122);
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.40493>; else goto <D.40494>;
      <D.40493>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.40495>; else goto <D.40496>;
      <D.40495>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40496>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40494>:
      D.40497 = mini_get_debug_options ();
      D.40498 = D.40497->break_on_unverified;
      if (D.40498 != 0) goto <D.40499>; else goto unverified;
      <D.40499>:
      raise (5);
      <D.27394>:
      <D.27389>:
      if (ip < end) goto <D.28167>; else goto <D.28168>;
      <D.28168>:
      if (start_new_bblock != 1) goto <D.40500>; else goto <D.40501>;
      <D.40500>:
      D.30389 = cfg->gsharedvt;
      if (D.30389 != 0) goto <D.40502>; else goto <D.40503>;
      <D.40502>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.40504>; else goto <D.40505>;
      <D.40504>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40505>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40503>:
      D.40506 = mini_get_debug_options ();
      D.40507 = D.40506->break_on_unverified;
      if (D.40507 != 0) goto <D.40508>; else goto unverified;
      <D.40508>:
      raise (5);
      <D.40501>:
      bblock.64 = bblock;
      ip.69 = (long int) ip;
      bblock.64 = bblock;
      D.30565 = bblock.64->cil_code;
      D.30568 = (long int) D.30565;
      D.30939 = ip.69 - D.30568;
      D.30940 = (int) D.30939;
      bblock.64->cil_length = D.30940;
      bblock.64 = bblock;
      D.40509 = bblock.64->next_bb;
      if (D.40509 != 0B) goto <D.40510>; else goto <D.40511>;
      <D.40510>:
      {
        struct MonoBasicBlock * bb;

        bb = bblock;
        goto <D.28171>;
        <D.28170>:
        bb = bb->next_bb;
        <D.28171>:
        D.40512 = bb->next_bb;
        if (D.40512 != 0B) goto <D.28170>; else goto <D.28172>;
        <D.28172>:
        bb->next_bb = end_bblock;
      }
      goto <D.40513>;
      <D.40511>:
      bblock.64 = bblock;
      bblock.64->next_bb = end_bblock;
      <D.40513>:
      D.30211 = cfg->method;
      if (D.30211 == method) goto <D.40514>; else goto <D.40515>;
      <D.40514>:
      D.40516 = cfg->domainvar;
      if (D.40516 != 0B) goto <D.40517>; else goto <D.40518>;
      <D.40517>:
      {
        struct MonoInst * store;
        struct MonoInst * get_domain;

        cfg->cbb = init_localsbb;
        get_domain = mono_get_domain_intrinsic (cfg);
        if (get_domain != 0B) goto <D.40519>; else goto <D.40520>;
        <D.40519>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.40521>; else goto <D.40522>;
        <D.40521>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = get_domain;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        get_domain->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = get_domain;
        goto <D.40523>;
        <D.40522>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = get_domain;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.40523>:
        goto <D.40524>;
        <D.40520>:
        get_domain = mono_emit_jit_icall (cfg, mono_domain_get, 0B);
        <D.40524>:
        D.30241 = cfg->mempool;
        store = mono_mempool_alloc (D.30241, 80);
        store->data.op[1].const_val = 0;
        D.40525 = store->data.op[1].const_val;
        store->data.op[0].const_val = D.40525;
        store->prev = 0B;
        D.40526 = store->prev;
        store->next = D.40526;
        store->opcode = 424;
        store->flags = 0;
        store->type = 0;
        store->dreg = -1;
        store->sreg3 = -1;
        D.40527 = store->sreg3;
        store->sreg2 = D.40527;
        D.40528 = store->sreg2;
        store->sreg1 = D.40528;
        D.30461 = cfg->ip;
        store->cil_code = D.30461;
        D.30978 = cfg->varinfo;
        D.40516 = cfg->domainvar;
        D.40529 = D.40516->data.op[0].const_val;
        D.40530 = (long unsigned int) D.40529;
        D.40531 = D.40530 * 8;
        D.40532 = D.30978 + D.40531;
        D.40533 = *D.40532;
        D.40534 = D.40533->data.op[1].vtype;
        D.40535 = mono_type_to_regmove (cfg, D.40534);
        D.40536 = (short unsigned int) D.40535;
        store->opcode = D.40536;
        D.30978 = cfg->varinfo;
        D.40516 = cfg->domainvar;
        D.40529 = D.40516->data.op[0].const_val;
        D.40530 = (long unsigned int) D.40529;
        D.40531 = D.40530 * 8;
        D.40532 = D.30978 + D.40531;
        D.40533 = *D.40532;
        D.40537 = D.40533->klass;
        store->klass = D.40537;
        D.40538 = get_domain->dreg;
        store->sreg1 = D.40538;
        D.30978 = cfg->varinfo;
        D.40516 = cfg->domainvar;
        D.40529 = D.40516->data.op[0].const_val;
        D.40530 = (long unsigned int) D.40529;
        D.40531 = D.40530 * 8;
        D.40532 = D.30978 + D.40531;
        D.40533 = *D.40532;
        D.40539 = D.40533->dreg;
        store->dreg = D.40539;
        D.40540 = store->opcode;
        if (D.40540 == 427) goto <D.40541>; else goto <D.40542>;
        <D.40541>:
        D.30978 = cfg->varinfo;
        D.40516 = cfg->domainvar;
        D.40529 = D.40516->data.op[0].const_val;
        D.40530 = (long unsigned int) D.40529;
        D.40531 = D.40530 * 8;
        D.40532 = D.30978 + D.40531;
        D.40533 = *D.40532;
        D.40534 = D.40533->data.op[1].vtype;
        D.40543 = mono_class_from_mono_type (D.40534);
        store->klass = D.40543;
        <D.40542>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        if (D.30490 != 0B) goto <D.40544>; else goto <D.40545>;
        <D.40544>:
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        D.30490->next = store;
        bblock.106 = cfg->cbb;
        D.30490 = bblock.106->last_ins;
        store->prev = D.30490;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = store;
        goto <D.40546>;
        <D.40545>:
        bblock.106 = cfg->cbb;
        bblock.106 = cfg->cbb;
        bblock.106->last_ins = store;
        D.30490 = bblock.106->last_ins;
        bblock.106->code = D.30490;
        <D.40546>:
      }
      <D.40518>:
      <D.40515>:
      D.30211 = cfg->method;
      if (D.30211 == method) goto <D.40547>; else goto <D.40548>;
      <D.40547>:
      D.40549 = cfg->got_var;
      if (D.40549 != 0B) goto <D.40550>; else goto <D.40551>;
      <D.40550>:
      mono_emit_load_got_addr (cfg);
      <D.40551>:
      <D.40548>:
      if (init_locals != 0) goto <D.40552>; else goto <D.40553>;
      <D.40552>:
      cfg->cbb = init_localsbb;
      cfg->ip = 0B;
      i = 0;
      goto <D.28176>;
      <D.28175>:
      D.40554 = header->locals[i];
      emit_init_local (cfg, i, D.40554);
      i = i + 1;
      <D.28176>:
      D.30829 = header->num_locals;
      D.30830 = (int) D.30829;
      if (D.30830 > i) goto <D.28175>; else goto <D.28177>;
      <D.28177>:
      <D.40553>:
      D.30634 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.40555 = D.30634 & 4;
      if (D.40555 != 0) goto <D.40556>; else goto <D.40557>;
      <D.40556>:
      D.30211 = cfg->method;
      if (D.30211 == method) goto <D.40558>; else goto <D.40559>;
      <D.40558>:
      i = 0;
      goto <D.28181>;
      <D.28180>:
      {
        struct MonoInst * ins;

        D.30978 = cfg->varinfo;
        D.30370 = (long unsigned int) i;
        D.30973 = D.30370 * 8;
        D.40560 = D.30978 + D.30973;
        ins = *D.40560;
        D.40561 = BIT_FIELD_REF <*ins, 64, 0>;
        D.40562 = D.40561 & 18446742974197923840;
        if (D.40562 == 92611864407572480) goto <D.40563>; else goto <D.40564>;
        <D.40563>:
        {
          struct MonoInst * inst;

          D.30241 = cfg->mempool;
          inst = mono_mempool_alloc (D.30241, 80);
          inst->data.op[1].const_val = 0;
          D.40565 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.40565;
          inst->prev = 0B;
          D.40566 = inst->prev;
          inst->next = D.40566;
          inst->opcode = 363;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.40567 = inst->sreg3;
          inst->sreg2 = D.40567;
          D.40568 = inst->sreg2;
          inst->sreg1 = D.40568;
          D.30461 = cfg->ip;
          inst->cil_code = D.30461;
          D.40569 = ins->dreg;
          inst->dreg = D.40569;
          inst->data.op[0].p = 0B;
          inst->type = 3;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          if (D.30490 != 0B) goto <D.40570>; else goto <D.40571>;
          <D.40570>:
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          D.30490->next = inst;
          bblock.106 = cfg->cbb;
          D.30490 = bblock.106->last_ins;
          inst->prev = D.30490;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          goto <D.40572>;
          <D.40571>:
          bblock.106 = cfg->cbb;
          bblock.106 = cfg->cbb;
          bblock.106->last_ins = inst;
          D.30490 = bblock.106->last_ins;
          bblock.106->code = D.30490;
          <D.40572>:
        }
        <D.40564>:
      }
      i = i + 1;
      <D.28181>:
      D.40573 = cfg->num_varinfo;
      i.98 = (unsigned int) i;
      if (D.40573 > i.98) goto <D.28180>; else goto <D.28182>;
      <D.28182>:
      <D.40559>:
      <D.40557>:
      D.33515 = cfg->lmf_var;
      if (D.33515 != 0B) goto <D.40574>; else goto <D.40575>;
      <D.40574>:
      D.30211 = cfg->method;
      if (D.30211 == method) goto <D.40576>; else goto <D.40577>;
      <D.40576>:
      cfg->cbb = init_localsbb;
      emit_push_lmf (cfg);
      <D.40577>:
      <D.40575>:
      if (seq_points != 0) goto <D.40578>; else goto <D.40579>;
      <D.40578>:
      {
        struct MonoBasicBlock * bb;

        bb = cfg->bb_entry;
        goto <D.28185>;
        <D.28184>:
        D.40580 = bb->code;
        if (D.40580 != 0B) goto <D.40581>; else goto <D.40582>;
        <D.40581>:
        D.40583 = bb->in_count;
        if (D.40583 > 1) goto <D.40584>; else goto <D.40585>;
        <D.40584>:
        D.40580 = bb->code;
        D.40586 = D.40580->opcode;
        if (D.40586 == 341) goto <D.40587>; else goto <D.40588>;
        <D.40587>:
        D.40580 = bb->code;
        D.40580 = bb->code;
        D.40589 = D.40580->flags;
        D.40590 = D.40589 | 1;
        D.40580->flags = D.40590;
        <D.40588>:
        <D.40585>:
        <D.40582>:
        bb = bb->next_bb;
        <D.28185>:
        if (bb != 0B) goto <D.28184>; else goto <D.28186>;
        <D.28186>:
      }
      <D.40579>:
      if (seq_points != 0) goto <D.40591>; else goto <D.40592>;
      <D.40591>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 341;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      ins->data.op[1].const_val = -1;
      ins->flags = 0;
      D.40593 = init_localsbb->last_ins;
      if (D.40593 != 0B) goto <D.40594>; else goto <D.40595>;
      <D.40594>:
      D.40593 = init_localsbb->last_ins;
      D.40593->next = ins;
      D.40593 = init_localsbb->last_ins;
      ins->prev = D.40593;
      init_localsbb->last_ins = ins;
      goto <D.40596>;
      <D.40595>:
      init_localsbb->last_ins = ins;
      D.40593 = init_localsbb->last_ins;
      init_localsbb->code = D.40593;
      <D.40596>:
      D.30241 = cfg->mempool;
      ins = mono_mempool_alloc (D.30241, 80);
      ins->data.op[1].const_val = 0;
      D.30457 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.30457;
      ins->prev = 0B;
      D.30458 = ins->prev;
      ins->next = D.30458;
      ins->opcode = 341;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.30459 = ins->sreg3;
      ins->sreg2 = D.30459;
      D.30460 = ins->sreg2;
      ins->sreg1 = D.30460;
      D.30461 = cfg->ip;
      ins->cil_code = D.30461;
      ins->data.op[1].const_val = 16777215;
      ins->flags = 0;
      D.40597 = cfg->bb_exit;
      D.40598 = D.40597->last_ins;
      if (D.40598 != 0B) goto <D.40599>; else goto <D.40600>;
      <D.40599>:
      D.40597 = cfg->bb_exit;
      D.40598 = D.40597->last_ins;
      D.40598->next = ins;
      D.40597 = cfg->bb_exit;
      D.40598 = D.40597->last_ins;
      ins->prev = D.40598;
      D.40597 = cfg->bb_exit;
      D.40597->last_ins = ins;
      goto <D.40601>;
      <D.40600>:
      D.40597 = cfg->bb_exit;
      D.40597 = cfg->bb_exit;
      D.40597->last_ins = ins;
      D.40598 = D.40597->last_ins;
      D.40597->code = D.40598;
      <D.40601>:
      <D.40592>:
      if (sym_seq_points != 0) goto <D.40602>; else goto <D.40603>;
      <D.40602>:
      i = 0;
      goto <D.28189>;
      <D.28188>:
      D.30370 = (long unsigned int) i;
      D.40604 = D.30370 / 64;
      D.40605 = seq_point_locs->data[D.40604];
      i.324 = (unsigned int) i;
      D.40607 = i.324 & 63;
      D.40608 = D.40605 >> D.40607;
      D.40609 = D.40608 & 1;
      if (D.40609 != 0) goto <D.40610>; else goto <D.40611>;
      <D.40610>:
      D.30370 = (long unsigned int) i;
      D.40604 = D.30370 / 64;
      D.40612 = seq_point_set_locs->data[D.40604];
      i.324 = (unsigned int) i;
      D.40607 = i.324 & 63;
      D.40613 = D.40612 >> D.40607;
      D.40614 = D.40613 & 1;
      if (D.40614 == 0) goto <D.40615>; else goto <D.40616>;
      <D.40615>:
      {
        struct MonoInst * ins;

        D.30241 = cfg->mempool;
        ins = mono_mempool_alloc (D.30241, 80);
        ins->data.op[1].const_val = 0;
        D.40617 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.40617;
        ins->prev = 0B;
        D.40618 = ins->prev;
        ins->next = D.40618;
        ins->opcode = 341;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.40619 = ins->sreg3;
        ins->sreg2 = D.40619;
        D.40620 = ins->sreg2;
        ins->sreg1 = D.40620;
        D.30461 = cfg->ip;
        ins->cil_code = D.30461;
        D.40621 = (long int) i;
        ins->data.op[1].const_val = D.40621;
        ins->flags = 0;
        mono_add_seq_point (cfg, 0B, ins, -1);
      }
      <D.40616>:
      <D.40611>:
      i = i + 1;
      <D.28189>:
      D.30219 = header->code_size;
      i.325 = (unsigned int) i;
      if (D.30219 > i.325) goto <D.28188>; else goto <D.28190>;
      <D.28190>:
      <D.40603>:
      cfg->ip = 0B;
      D.30211 = cfg->method;
      if (D.30211 == method) goto <D.40623>; else goto <D.40624>;
      <D.40623>:
      {
        struct MonoBasicBlock * bb;

        bb = cfg->bb_entry;
        goto <D.28193>;
        <D.28192>:
        D.40625 = bb->real_offset;
        D.40626 = (int) D.40625;
        D.40627 = mono_find_block_region (cfg, D.40626);
        D.40628 = (unsigned int) D.40627;
        bb->region = D.40628;
        D.40629 = cfg->spvars;
        if (D.40629 != 0B) goto <D.40630>; else goto <D.40631>;
        <D.40630>:
        D.40632 = bb->region;
        D.40633 = (int) D.40632;
        mono_create_spvar_for_region (cfg, D.40633);
        <D.40631>:
        D.30322 = cfg->verbose_level;
        if (D.30322 > 2) goto <D.40634>; else goto <D.40635>;
        <D.40634>:
        D.40636 = bb->block_num;
        D.40625 = bb->real_offset;
        D.40632 = bb->region;
        printf ("REGION BB%d IL_%04x ID_%08X\n", D.40636, D.40625, D.40632);
        <D.40635>:
        bb = bb->next_bb;
        <D.28193>:
        if (bb != 0B) goto <D.28192>; else goto <D.28194>;
        <D.28194>:
      }
      <D.40624>:
      monoeg_g_slist_free (class_inits);
      dont_inline = monoeg_g_list_remove (dont_inline, method);
      if (inline_costs < 0) goto <D.40637>; else goto <D.40638>;
      <D.40637>:
      {
        char * mname;

        mname = mono_method_full_name (method, 1);
        mono_cfg_set_exception (cfg, 3);
        D.40639 = monoeg_g_strdup_printf ("Method %s is too complex.", mname);
        cfg->exception_message = D.40639;
        monoeg_g_free (mname);
        D.30241 = cfg->mempool;
        D.40640 = cfg->headers_to_free;
        D.40641 = g_slist_prepend_mempool (D.30241, D.40640, header);
        cfg->headers_to_free = D.40641;
        mono_basic_block_free (original_bb);
        D.40642 = -1;
        return D.40642;
      }
      <D.40638>:
      D.30322 = cfg->verbose_level;
      if (D.30322 > 2) goto <D.40643>; else goto <D.40644>;
      <D.40643>:
      D.30211 = cfg->method;
      if (D.30211 == method) goto <D.40645>; else goto <D.40646>;
      <D.40645>:
      mono_print_code (cfg, "AFTER METHOD-TO-IR");
      <D.40646>:
      <D.40644>:
      D.30241 = cfg->mempool;
      D.40640 = cfg->headers_to_free;
      D.40647 = g_slist_prepend_mempool (D.30241, D.40640, header);
      cfg->headers_to_free = D.40647;
      mono_basic_block_free (original_bb);
      D.40642 = inline_costs;
      return D.40642;
      exception_exit:
      D.30793 = cfg->exception_type;
      D.40648 = D.30793 == 0;
      D.40649 = (long int) D.40648;
      D.40650 = __builtin_expect (D.40649, 0);
      if (D.40650 != 0) goto <D.40651>; else goto <D.40652>;
      <D.40651>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 12004, "cfg->exception_type != MONO_EXCEPTION_NONE");
      <D.40652>:
      goto cleanup;
      inline_failure:
      goto cleanup;
      load_error:
      mono_cfg_set_exception (cfg, 7);
      goto cleanup;
      unverified:
      set_exception_type_from_invalid_il (cfg, method, ip);
      goto cleanup;
      cleanup:
      monoeg_g_slist_free (class_inits);
      mono_basic_block_free (original_bb);
      dont_inline = monoeg_g_list_remove (dont_inline, method);
      D.30241 = cfg->mempool;
      D.40640 = cfg->headers_to_free;
      D.40653 = g_slist_prepend_mempool (D.30241, D.40640, header);
      cfg->headers_to_free = D.40653;
      D.40642 = -1;
      return D.40642;
    }
  finally
    {
      error = {CLOBBER};
      bblock = {CLOBBER};
      klass = {CLOBBER};
      err_pos = {CLOBBER};
      actions = {CLOBBER};
      cached_tls_addr = {CLOBBER};
    }
}


is_jit_optimizer_disabled (struct MonoMethod * m)
{
  struct MonoClass * D.40716;
  struct MonoImage * D.40717;
  _Bool D.40718;
  long int D.40719;
  long int D.40720;
  unsigned char D.40723;
  gboolean D.40726;
  unsigned char D.40727;
  struct MonoClass * klass.326;
  struct MonoImage * D.40731;
  struct MonoClass * klass.327;
  struct MonoMethod * D.40739;
  struct MonoClass * D.40741;
  unsigned int D.40742;
  short unsigned int D.40743;
  short unsigned int D.40744;
  int D.40745;
  int D.40746;
  int D.40747;
  int D.40748;
  int D.40749;
  _Bool D.40750;
  long int D.40751;
  long int D.40752;
  short unsigned int D.40757;
  struct MonoType * D.40759;
  unsigned char D.40760;
  struct MonoType * D.40762;
  unsigned char D.40763;
  char D.40764;
  int D.40765;
  unsigned char D.40766;
  struct MonoAssembly * ass;
  struct MonoCustomAttrInfo * attrs;
  static struct MonoClass * klass;
  int i;
  gboolean val;

  D.40716 = m->klass;
  D.40717 = D.40716->image;
  ass = D.40717->assembly;
  val = 0;
  D.40718 = ass == 0B;
  D.40719 = (long int) D.40718;
  D.40720 = __builtin_expect (D.40719, 0);
  if (D.40720 != 0) goto <D.40721>; else goto <D.40722>;
  <D.40721>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6422, "ass");
  <D.40722>:
  D.40723 = ass->jit_optimizer_disabled_inited;
  if (D.40723 != 0) goto <D.40724>; else goto <D.40725>;
  <D.40724>:
  D.40727 = ass->jit_optimizer_disabled;
  D.40726 = (gboolean) D.40727;
  return D.40726;
  <D.40725>:
  klass.326 = klass;
  if (klass.326 == 0B) goto <D.40729>; else goto <D.40730>;
  <D.40729>:
  D.40731 = mono_defaults.corlib;
  klass.327 = mono_class_from_name (D.40731, "System.Diagnostics", "DebuggableAttribute");
  klass = klass.327;
  <D.40730>:
  klass.326 = klass;
  if (klass.326 == 0B) goto <D.40733>; else goto <D.40734>;
  <D.40733>:
  ass->jit_optimizer_disabled = 0;
  mono_memory_barrier ();
  ass->jit_optimizer_disabled_inited = 1;
  D.40726 = 0;
  return D.40726;
  <D.40734>:
  attrs = mono_custom_attrs_from_assembly (ass);
  if (attrs != 0B) goto <D.40735>; else goto <D.40736>;
  <D.40735>:
  i = 0;
  goto <D.27225>;
  <D.27224>:
  {
    struct MonoCustomAttrEntry * attr;
    const gchar * p;
    int len;
    struct MonoMethodSignature * sig;

    attr = &attrs->attrs[i];
    D.40739 = attr->ctor;
    if (D.40739 == 0B) goto <D.40737>; else goto <D.40740>;
    <D.40740>:
    D.40739 = attr->ctor;
    D.40741 = D.40739->klass;
    klass.326 = klass;
    if (D.40741 != klass.326) goto <D.40737>; else goto <D.40738>;
    <D.40737>:
    // predicted unlikely by continue predictor.
    goto <D.27223>;
    <D.40738>:
    D.40742 = attr->data_size;
    len = (int) D.40742;
    p = attr->data;
    D.40743 = MEM[(const guint16 *)p];
    D.40744 = D.40743 >> 8;
    D.40745 = (int) D.40744;
    D.40743 = MEM[(const guint16 *)p];
    D.40746 = (int) D.40743;
    D.40747 = D.40746 << 8;
    D.40748 = D.40747 & 65535;
    D.40749 = D.40745 | D.40748;
    D.40750 = D.40749 != 1;
    D.40751 = (long int) D.40750;
    D.40752 = __builtin_expect (D.40751, 0);
    if (D.40752 != 0) goto <D.40753>; else goto <D.40754>;
    <D.40753>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6449, "read16 (p) == 0x0001");
    <D.40754>:
    p = p + 2;
    D.40739 = attr->ctor;
    sig = mono_method_signature (D.40739);
    D.40757 = sig->param_count;
    if (D.40757 != 2) goto <D.40755>; else goto <D.40758>;
    <D.40758>:
    D.40759 = sig->params[0];
    D.40760 = D.40759->type;
    if (D.40760 != 2) goto <D.40755>; else goto <D.40761>;
    <D.40761>:
    D.40762 = sig->params[1];
    D.40763 = D.40762->type;
    if (D.40763 != 2) goto <D.40755>; else goto <D.40756>;
    <D.40755>:
    // predicted unlikely by continue predictor.
    goto <D.27223>;
    <D.40756>:
    p = p + 1;
    D.40764 = *p;
    val = (gboolean) D.40764;
  }
  <D.27223>:
  i = i + 1;
  <D.27225>:
  D.40765 = attrs->num_attrs;
  if (D.40765 > i) goto <D.27224>; else goto <D.27226>;
  <D.27226>:
  mono_custom_attrs_free (attrs);
  <D.40736>:
  D.40766 = (unsigned char) val;
  ass->jit_optimizer_disabled = D.40766;
  mono_memory_barrier ();
  ass->jit_optimizer_disabled_inited = 1;
  D.40726 = val;
  return D.40726;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


mono_create_exvar_for_offset (struct MonoCompile * cfg, int offset)
{
  struct GHashTable * D.40768;
  long int D.40769;
  const void * D.40770;
  struct MonoInst * D.40773;
  struct MonoClass * D.40774;
  struct MonoType * D.40775;
  unsigned char D.40776;
  unsigned char D.40777;
  void * D.40778;
  struct MonoInst * var;

  D.40768 = cfg->exvars;
  D.40769 = (long int) offset;
  D.40770 = (const void *) D.40769;
  var = monoeg_g_hash_table_lookup (D.40768, D.40770);
  if (var != 0B) goto <D.40771>; else goto <D.40772>;
  <D.40771>:
  D.40773 = var;
  return D.40773;
  <D.40772>:
  D.40774 = mono_defaults.object_class;
  D.40775 = &D.40774->byval_arg;
  var = mono_compile_create_var (cfg, D.40775, 329);
  D.40776 = var->flags;
  D.40777 = D.40776 | 4;
  var->flags = D.40777;
  D.40768 = cfg->exvars;
  D.40769 = (long int) offset;
  D.40778 = (void *) D.40769;
  monoeg_g_hash_table_insert_replace (D.40768, D.40778, var, 0);
  D.40773 = var;
  return D.40773;
}


mono_save_args (struct MonoCompile * cfg, struct MonoMethodSignature * sig, struct MonoInst * * sp)
{
  struct MonoType * iftmp.328;
  long unsigned int D.40783;
  long unsigned int D.40784;
  struct MonoInst * D.40787;
  <unnamed-unsigned:1> D.40788;
  int D.40789;
  int D.40790;
  struct MonoInst * * D.40791;
  long unsigned int D.40792;
  long unsigned int D.40793;
  struct MonoInst * * D.40794;
  struct MonoMemPool * D.40795;
  long int D.40796;
  struct MonoInst * D.40797;
  int D.40798;
  int D.40799;
  const unsigned char * D.40800;
  struct MonoType * * D.40801;
  struct MonoType * * D.40802;
  struct MonoType * D.40803;
  unsigned int D.40804;
  short unsigned int D.40805;
  struct MonoInst * D.40806;
  struct MonoClass * D.40807;
  int D.40808;
  int D.40809;
  short unsigned int D.40810;
  struct MonoClass * D.40813;
  struct MonoBasicBlock * D.40814;
  struct MonoInst * D.40815;
  const unsigned char * D.40819;
  short unsigned int D.40820;
  int D.40821;
  int D.40822;
  struct MonoInst * store;
  struct MonoInst * temp;
  int i;

  i = 0;
  goto <D.26952>;
  <D.26951>:
  {
    struct MonoType * argtype;

    D.40783 = BIT_FIELD_REF <*sig, 64, 64>;
    D.40784 = D.40783 & 512;
    if (D.40784 != 0) goto <D.40785>; else goto <D.40781>;
    <D.40785>:
    if (i == 0) goto <D.40786>; else goto <D.40781>;
    <D.40786>:
    D.40787 = *sp;
    iftmp.328 = type_from_stack_type (D.40787);
    goto <D.40782>;
    <D.40781>:
    D.40788 = sig->hasthis;
    D.40789 = (int) D.40788;
    D.40790 = i - D.40789;
    iftmp.328 = sig->params[D.40790];
    <D.40782>:
    argtype = iftmp.328;
    temp = mono_compile_create_var (cfg, argtype, 329);
    D.40791 = cfg->args;
    D.40792 = (long unsigned int) i;
    D.40793 = D.40792 * 8;
    D.40794 = D.40791 + D.40793;
    *D.40794 = temp;
    D.40795 = cfg->mempool;
    store = mono_mempool_alloc (D.40795, 80);
    store->data.op[1].const_val = 0;
    D.40796 = store->data.op[1].const_val;
    store->data.op[0].const_val = D.40796;
    store->prev = 0B;
    D.40797 = store->prev;
    store->next = D.40797;
    store->opcode = 424;
    store->flags = 0;
    store->type = 0;
    store->dreg = -1;
    store->sreg3 = -1;
    D.40798 = store->sreg3;
    store->sreg2 = D.40798;
    D.40799 = store->sreg2;
    store->sreg1 = D.40799;
    D.40800 = cfg->ip;
    store->cil_code = D.40800;
    D.40801 = cfg->arg_types;
    D.40792 = (long unsigned int) i;
    D.40793 = D.40792 * 8;
    D.40802 = D.40801 + D.40793;
    D.40803 = *D.40802;
    D.40804 = mono_type_to_regmove (cfg, D.40803);
    D.40805 = (short unsigned int) D.40804;
    store->opcode = D.40805;
    D.40791 = cfg->args;
    D.40792 = (long unsigned int) i;
    D.40793 = D.40792 * 8;
    D.40794 = D.40791 + D.40793;
    D.40806 = *D.40794;
    D.40807 = D.40806->klass;
    store->klass = D.40807;
    D.40787 = *sp;
    D.40808 = D.40787->dreg;
    store->sreg1 = D.40808;
    D.40791 = cfg->args;
    D.40792 = (long unsigned int) i;
    D.40793 = D.40792 * 8;
    D.40794 = D.40791 + D.40793;
    D.40806 = *D.40794;
    D.40809 = D.40806->dreg;
    store->dreg = D.40809;
    D.40810 = store->opcode;
    if (D.40810 == 427) goto <D.40811>; else goto <D.40812>;
    <D.40811>:
    D.40801 = cfg->arg_types;
    D.40792 = (long unsigned int) i;
    D.40793 = D.40792 * 8;
    D.40802 = D.40801 + D.40793;
    D.40803 = *D.40802;
    D.40813 = mono_class_from_mono_type (D.40803);
    store->klass = D.40813;
    <D.40812>:
    D.40814 = cfg->cbb;
    D.40815 = D.40814->last_ins;
    if (D.40815 != 0B) goto <D.40816>; else goto <D.40817>;
    <D.40816>:
    D.40814 = cfg->cbb;
    D.40815 = D.40814->last_ins;
    D.40815->next = store;
    D.40814 = cfg->cbb;
    D.40815 = D.40814->last_ins;
    store->prev = D.40815;
    D.40814 = cfg->cbb;
    D.40814->last_ins = store;
    goto <D.40818>;
    <D.40817>:
    D.40814 = cfg->cbb;
    D.40814 = cfg->cbb;
    D.40814->last_ins = store;
    D.40815 = D.40814->last_ins;
    D.40814->code = D.40815;
    <D.40818>:
    D.40787 = *sp;
    D.40819 = D.40787->cil_code;
    store->cil_code = D.40819;
    sp = sp + 8;
  }
  i = i + 1;
  <D.26952>:
  D.40820 = sig->param_count;
  D.40821 = (int) D.40820;
  D.40788 = sig->hasthis;
  D.40789 = (int) D.40788;
  D.40822 = D.40821 + D.40789;
  if (D.40822 > i) goto <D.26951>; else goto <D.26953>;
  <D.26953>:
}


emit_get_rgctx_gsharedvt_method (struct MonoCompile * cfg, int context_used, struct MonoMethod * cmethod, struct MonoGSharedVtMethodInfo * info)
{
  struct MonoMemPool * D.40823;
  struct MonoMethod * D.40824;
  int D.40825;
  struct MonoInst * D.40826;
  struct MonoJumpInfoRgctxEntry * entry;
  struct MonoInst * rgctx;

  D.40823 = cfg->mempool;
  D.40824 = cfg->current_method;
  D.40825 = context_used & 2;
  entry = mono_patch_info_rgctx_entry_new (D.40823, D.40824, D.40825, 46, info, 20);
  D.40824 = cfg->current_method;
  rgctx = emit_get_rgctx (cfg, D.40824, context_used);
  D.40826 = emit_rgctx_fetch (cfg, rgctx, entry);
  return D.40826;
}


emit_throw_exception (struct MonoCompile * cfg, struct MonoException * ex)
{
  struct MonoMemPool * D.40828;
  void * D.40829;
  struct MonoInst * D.40830;
  long int D.40831;
  struct MonoInst * D.40832;
  int D.40833;
  int D.40834;
  const unsigned char * D.40835;
  unsigned int D.40836;
  int D.40837;
  struct MonoBasicBlock * D.40838;
  struct MonoInst * D.40839;
  struct MonoMethod * thrower;
  struct MonoInst * args[1];

  try
    {
      thrower = throw_exception ();
      D.40828 = cfg->mempool;
      D.40829 = mono_mempool_alloc (D.40828, 80);
      args[0] = D.40829;
      D.40830 = args[0];
      D.40830 = args[0];
      D.40830->data.op[1].const_val = 0;
      D.40831 = D.40830->data.op[1].const_val;
      D.40830->data.op[0].const_val = D.40831;
      D.40830 = args[0];
      D.40830 = args[0];
      D.40830->prev = 0B;
      D.40832 = D.40830->prev;
      D.40830->next = D.40832;
      D.40830 = args[0];
      D.40830->opcode = 363;
      D.40830 = args[0];
      D.40830->flags = 0;
      D.40830 = args[0];
      D.40830->type = 0;
      D.40830 = args[0];
      D.40830->dreg = -1;
      D.40830 = args[0];
      D.40830 = args[0];
      D.40830 = args[0];
      D.40830->sreg3 = -1;
      D.40833 = D.40830->sreg3;
      D.40830->sreg2 = D.40833;
      D.40834 = D.40830->sreg2;
      D.40830->sreg1 = D.40834;
      D.40830 = args[0];
      D.40835 = cfg->ip;
      D.40830->cil_code = D.40835;
      D.40830 = args[0];
      D.40830->data.op[0].p = ex;
      D.40830 = args[0];
      D.40830->type = 3;
      D.40830 = args[0];
      D.40836 = alloc_dreg (cfg, 3);
      D.40837 = (int) D.40836;
      D.40830->dreg = D.40837;
      D.40838 = cfg->cbb;
      D.40839 = D.40838->last_ins;
      if (D.40839 != 0B) goto <D.40840>; else goto <D.40841>;
      <D.40840>:
      D.40838 = cfg->cbb;
      D.40839 = D.40838->last_ins;
      D.40830 = args[0];
      D.40839->next = D.40830;
      D.40830 = args[0];
      D.40838 = cfg->cbb;
      D.40839 = D.40838->last_ins;
      D.40830->prev = D.40839;
      D.40838 = cfg->cbb;
      D.40830 = args[0];
      D.40838->last_ins = D.40830;
      goto <D.40842>;
      <D.40841>:
      D.40838 = cfg->cbb;
      D.40838 = cfg->cbb;
      D.40830 = args[0];
      D.40838->last_ins = D.40830;
      D.40839 = D.40838->last_ins;
      D.40838->code = D.40839;
      <D.40842>:
      mono_emit_method_call (cfg, thrower, &args, 0B);
    }
  finally
    {
      args = {CLOBBER};
    }
}


throw_exception ()
{
  struct MonoMethod * method.329;
  struct MonoClass * D.40846;
  struct MonoMethod * method.330;
  _Bool D.40848;
  long int D.40849;
  long int D.40850;
  struct MonoMethod * D.40853;
  static struct MonoMethod * method = 0B;

  method.329 = method;
  if (method.329 == 0B) goto <D.40844>; else goto <D.40845>;
  <D.40844>:
  {
    struct MonoSecurityManager * secman;

    secman = mono_security_manager_get_methods ();
    D.40846 = secman->securitymanager;
    method.330 = mono_class_get_method_from_name (D.40846, "ThrowException", 1);
    method = method.330;
  }
  <D.40845>:
  method.329 = method;
  D.40848 = method.329 == 0B;
  D.40849 = (long int) D.40848;
  D.40850 = __builtin_expect (D.40849, 0);
  if (D.40850 != 0) goto <D.40851>; else goto <D.40852>;
  <D.40851>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6187, "method");
  <D.40852>:
  D.40853 = method;
  return D.40853;
}


get_basic_blocks (struct MonoCompile * cfg, struct MonoMethodHeader * header, guint real_offset, unsigned char * start, unsigned char * end, unsigned char * * pos)
{
  unsigned char * ip.331;
  long int ip.332;
  long int start.333;
  long int D.40858;
  <unnamed type> D.40859;
  int D.40862;
  unsigned int D.40865;
  struct MonoDebugOptions * D.40868;
  int D.40869;
  unsigned char D.40871;
  int D.40872;
  unsigned char * ip.334;
  unsigned char * ip.335;
  unsigned char * ip.336;
  unsigned char * ip.337;
  sizetype D.40877;
  unsigned char D.40878;
  signed char D.40879;
  sizetype D.40880;
  sizetype D.40881;
  sizetype D.40882;
  struct MonoBasicBlock * * D.40883;
  long int target.338;
  unsigned char * D.40885;
  long int D.40886;
  long int D.40887;
  long unsigned int D.40888;
  long unsigned int D.40889;
  struct MonoBasicBlock * * D.40890;
  const unsigned char * D.40896;
  struct MonoDebugOptions * D.40901;
  int D.40902;
  struct MonoMemPool * D.40904;
  unsigned int D.40905;
  unsigned int D.40906;
  unsigned int D.40907;
  int D.40908;
  unsigned char * D.40909;
  long int D.40912;
  long int D.40913;
  long unsigned int D.40914;
  long unsigned int D.40915;
  struct MonoBasicBlock * * D.40916;
  unsigned int D.40917;
  long int D.40920;
  long unsigned int D.40921;
  long unsigned int D.40922;
  struct MonoBasicBlock * * D.40923;
  struct MonoDebugOptions * D.40933;
  int D.40934;
  unsigned int D.40936;
  unsigned int D.40937;
  int D.40938;
  unsigned int D.40941;
  unsigned int D.40942;
  unsigned int D.40943;
  unsigned int D.40944;
  unsigned int D.40945;
  unsigned int D.40946;
  unsigned int D.40947;
  unsigned int D.40948;
  unsigned int D.40949;
  unsigned int D.40950;
  int D.40951;
  sizetype D.40952;
  sizetype D.40953;
  sizetype D.40954;
  struct MonoDebugOptions * D.40964;
  int D.40965;
  unsigned int D.40967;
  unsigned int D.40968;
  int D.40969;
  struct MonoDebugOptions * D.40983;
  int D.40984;
  unsigned int D.40986;
  unsigned int D.40987;
  int D.40988;
  unsigned int D.40991;
  unsigned int D.40992;
  struct MonoDebugOptions * D.41002;
  int D.41003;
  unsigned int D.41005;
  unsigned int D.41006;
  int D.41007;
  unsigned int D.41010;
  unsigned int D.41011;
  unsigned int D.41012;
  unsigned int D.41013;
  unsigned int D.41014;
  unsigned int D.41015;
  unsigned int D.41016;
  unsigned int D.41017;
  unsigned int D.41018;
  unsigned int D.41019;
  int D.41020;
  sizetype D.41021;
  sizetype D.41022;
  struct MonoDebugOptions * D.41032;
  int D.41033;
  unsigned int D.41035;
  unsigned int D.41036;
  int D.41037;
  unsigned char * ip.339;
  unsigned char * ip.340;
  long int bb_start.341;
  long int D.41045;
  long unsigned int D.41046;
  long unsigned int D.41047;
  struct MonoBasicBlock * * D.41048;
  int D.41052;
  unsigned char * ip;
  unsigned char * target;
  int i;
  guint cli_addr;
  struct MonoBasicBlock * bblock;
  const struct MonoOpcode * opcode;
  void exception_exit = <<< error >>>;
  void unverified = <<< error >>>;

  try
    {
      ip = start;
      goto <D.27082>;
      <D.27081>:
      ip.331 = ip;
      ip.332 = (long int) ip.331;
      start.333 = (long int) start;
      D.40858 = ip.332 - start.333;
      cli_addr = (guint) D.40858;
      D.40859 = mono_opcode_value (&ip, end);
      i = (int) D.40859;
      if (i < 0) goto <D.40860>; else goto <D.40861>;
      <D.40860>:
      D.40862 = cfg->gsharedvt;
      if (D.40862 != 0) goto <D.40863>; else goto <D.40864>;
      <D.40863>:
      D.40865 = cfg->verbose_level;
      if (D.40865 > 2) goto <D.40866>; else goto <D.40867>;
      <D.40866>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40867>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40864>:
      D.40868 = mini_get_debug_options ();
      D.40869 = D.40868->break_on_unverified;
      if (D.40869 != 0) goto <D.40870>; else goto unverified;
      <D.40870>:
      raise (5);
      <D.40861>:
      opcode = &mono_opcodes[i];
      D.40871 = opcode->argument;
      D.40872 = (int) D.40871;
      switch (D.40872) <default: <D.27076>, case 0: <D.27053>, case 1: <D.27056>, case 2: <D.27057>, case 3: <D.27058>, case 4: <D.27059>, case 5: <D.27055>, case 6: <D.27060>, case 7: <D.27063>, case 8: <D.27064>, case 9: <D.27067>, case 10: <D.27066>, case 11: <D.27068>, case 12: <D.27074>, case 13: <D.27061>, case 14: <D.27062>, case 15: <D.27065>, case 16: <D.27075>>
      <D.27053>:
      ip.331 = ip;
      ip.334 = ip.331 + 1;
      ip = ip.334;
      goto <D.27054>;
      <D.27055>:
      <D.27056>:
      <D.27057>:
      <D.27058>:
      <D.27059>:
      <D.27060>:
      <D.27061>:
      <D.27062>:
      ip.331 = ip;
      ip.335 = ip.331 + 5;
      ip = ip.335;
      goto <D.27054>;
      <D.27063>:
      ip.331 = ip;
      ip.336 = ip.331 + 3;
      ip = ip.336;
      goto <D.27054>;
      <D.27064>:
      <D.27065>:
      ip.331 = ip;
      ip.337 = ip.331 + 2;
      ip = ip.337;
      goto <D.27054>;
      <D.27066>:
      D.40877 = (sizetype) cli_addr;
      ip.331 = ip;
      ip.334 = ip.331 + 1;
      D.40878 = *ip.334;
      D.40879 = (signed char) D.40878;
      D.40880 = (sizetype) D.40879;
      D.40881 = D.40877 + D.40880;
      D.40882 = D.40881 + 2;
      target = start + D.40882;
      D.40883 = cfg->cil_offset_to_bb;
      target.338 = (long int) target;
      D.40885 = cfg->cil_start;
      D.40886 = (long int) D.40885;
      D.40887 = target.338 - D.40886;
      D.40888 = (long unsigned int) D.40887;
      D.40889 = D.40888 * 8;
      D.40890 = D.40883 + D.40889;
      bblock = *D.40890;
      if (bblock == 0B) goto <D.40891>; else goto <D.40892>;
      <D.40891>:
      if (target >= end) goto <D.40893>; else goto <D.40895>;
      <D.40895>:
      D.40896 = header->code;
      if (D.40896 > target) goto <D.40893>; else goto <D.40894>;
      <D.40893>:
      D.40862 = cfg->gsharedvt;
      if (D.40862 != 0) goto <D.40897>; else goto <D.40898>;
      <D.40897>:
      D.40865 = cfg->verbose_level;
      if (D.40865 > 2) goto <D.40899>; else goto <D.40900>;
      <D.40899>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40900>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40898>:
      D.40901 = mini_get_debug_options ();
      D.40902 = D.40901->break_on_unverified;
      if (D.40902 != 0) goto <D.40903>; else goto unverified;
      <D.40903>:
      raise (5);
      <D.40894>:
      D.40904 = cfg->mempool;
      bblock = mono_mempool_alloc0 (D.40904, 296);
      D.40905 = cfg->num_bblocks;
      D.40906 = D.40905;
      D.40907 = D.40906 + 1;
      cfg->num_bblocks = D.40907;
      D.40908 = (int) D.40906;
      bblock->block_num = D.40908;
      bblock->cil_code = target;
      D.40909 = bblock->cil_code;
      if (D.40909 != 0B) goto <D.40910>; else goto <D.40911>;
      <D.40910>:
      D.40883 = cfg->cil_offset_to_bb;
      D.40909 = bblock->cil_code;
      D.40912 = (long int) D.40909;
      D.40885 = cfg->cil_start;
      D.40886 = (long int) D.40885;
      D.40913 = D.40912 - D.40886;
      D.40914 = (long unsigned int) D.40913;
      D.40915 = D.40914 * 8;
      D.40916 = D.40883 + D.40915;
      *D.40916 = bblock;
      <D.40911>:
      D.40917 = cfg->real_offset;
      bblock->real_offset = D.40917;
      <D.40892>:
      ip.331 = ip;
      ip.337 = ip.331 + 2;
      ip = ip.337;
      ip.331 = ip;
      if (ip.331 < end) goto <D.40918>; else goto <D.40919>;
      <D.40918>:
      D.40883 = cfg->cil_offset_to_bb;
      ip.331 = ip;
      ip.332 = (long int) ip.331;
      D.40885 = cfg->cil_start;
      D.40886 = (long int) D.40885;
      D.40920 = ip.332 - D.40886;
      D.40921 = (long unsigned int) D.40920;
      D.40922 = D.40921 * 8;
      D.40923 = D.40883 + D.40922;
      bblock = *D.40923;
      if (bblock == 0B) goto <D.40924>; else goto <D.40925>;
      <D.40924>:
      ip.331 = ip;
      if (ip.331 >= end) goto <D.40926>; else goto <D.40928>;
      <D.40928>:
      D.40896 = header->code;
      ip.331 = ip;
      if (D.40896 > ip.331) goto <D.40926>; else goto <D.40927>;
      <D.40926>:
      D.40862 = cfg->gsharedvt;
      if (D.40862 != 0) goto <D.40929>; else goto <D.40930>;
      <D.40929>:
      D.40865 = cfg->verbose_level;
      if (D.40865 > 2) goto <D.40931>; else goto <D.40932>;
      <D.40931>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40932>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40930>:
      D.40933 = mini_get_debug_options ();
      D.40934 = D.40933->break_on_unverified;
      if (D.40934 != 0) goto <D.40935>; else goto unverified;
      <D.40935>:
      raise (5);
      <D.40927>:
      D.40904 = cfg->mempool;
      bblock = mono_mempool_alloc0 (D.40904, 296);
      D.40905 = cfg->num_bblocks;
      D.40936 = D.40905;
      D.40937 = D.40936 + 1;
      cfg->num_bblocks = D.40937;
      D.40938 = (int) D.40936;
      bblock->block_num = D.40938;
      ip.331 = ip;
      bblock->cil_code = ip.331;
      D.40909 = bblock->cil_code;
      if (D.40909 != 0B) goto <D.40939>; else goto <D.40940>;
      <D.40939>:
      D.40883 = cfg->cil_offset_to_bb;
      D.40909 = bblock->cil_code;
      D.40912 = (long int) D.40909;
      D.40885 = cfg->cil_start;
      D.40886 = (long int) D.40885;
      D.40913 = D.40912 - D.40886;
      D.40914 = (long unsigned int) D.40913;
      D.40915 = D.40914 * 8;
      D.40916 = D.40883 + D.40915;
      *D.40916 = bblock;
      <D.40940>:
      D.40917 = cfg->real_offset;
      bblock->real_offset = D.40917;
      <D.40925>:
      <D.40919>:
      goto <D.27054>;
      <D.27067>:
      D.40877 = (sizetype) cli_addr;
      ip.331 = ip;
      ip.334 = ip.331 + 1;
      D.40941 = MEM[(const guint32 *)ip.334];
      D.40942 = D.40941 << 24;
      ip.331 = ip;
      ip.334 = ip.331 + 1;
      D.40941 = MEM[(const guint32 *)ip.334];
      D.40943 = D.40941 >> 8;
      D.40944 = D.40943 & 65280;
      D.40945 = D.40942 | D.40944;
      ip.331 = ip;
      ip.334 = ip.331 + 1;
      D.40941 = MEM[(const guint32 *)ip.334];
      D.40946 = D.40941 << 8;
      D.40947 = D.40946 & 16711680;
      D.40948 = D.40945 | D.40947;
      ip.331 = ip;
      ip.334 = ip.331 + 1;
      D.40941 = MEM[(const guint32 *)ip.334];
      D.40949 = D.40941 >> 24;
      D.40950 = D.40948 | D.40949;
      D.40951 = (int) D.40950;
      D.40952 = (sizetype) D.40951;
      D.40953 = D.40877 + D.40952;
      D.40954 = D.40953 + 5;
      target = start + D.40954;
      D.40883 = cfg->cil_offset_to_bb;
      target.338 = (long int) target;
      D.40885 = cfg->cil_start;
      D.40886 = (long int) D.40885;
      D.40887 = target.338 - D.40886;
      D.40888 = (long unsigned int) D.40887;
      D.40889 = D.40888 * 8;
      D.40890 = D.40883 + D.40889;
      bblock = *D.40890;
      if (bblock == 0B) goto <D.40955>; else goto <D.40956>;
      <D.40955>:
      if (target >= end) goto <D.40957>; else goto <D.40959>;
      <D.40959>:
      D.40896 = header->code;
      if (D.40896 > target) goto <D.40957>; else goto <D.40958>;
      <D.40957>:
      D.40862 = cfg->gsharedvt;
      if (D.40862 != 0) goto <D.40960>; else goto <D.40961>;
      <D.40960>:
      D.40865 = cfg->verbose_level;
      if (D.40865 > 2) goto <D.40962>; else goto <D.40963>;
      <D.40962>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40963>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40961>:
      D.40964 = mini_get_debug_options ();
      D.40965 = D.40964->break_on_unverified;
      if (D.40965 != 0) goto <D.40966>; else goto unverified;
      <D.40966>:
      raise (5);
      <D.40958>:
      D.40904 = cfg->mempool;
      bblock = mono_mempool_alloc0 (D.40904, 296);
      D.40905 = cfg->num_bblocks;
      D.40967 = D.40905;
      D.40968 = D.40967 + 1;
      cfg->num_bblocks = D.40968;
      D.40969 = (int) D.40967;
      bblock->block_num = D.40969;
      bblock->cil_code = target;
      D.40909 = bblock->cil_code;
      if (D.40909 != 0B) goto <D.40970>; else goto <D.40971>;
      <D.40970>:
      D.40883 = cfg->cil_offset_to_bb;
      D.40909 = bblock->cil_code;
      D.40912 = (long int) D.40909;
      D.40885 = cfg->cil_start;
      D.40886 = (long int) D.40885;
      D.40913 = D.40912 - D.40886;
      D.40914 = (long unsigned int) D.40913;
      D.40915 = D.40914 * 8;
      D.40916 = D.40883 + D.40915;
      *D.40916 = bblock;
      <D.40971>:
      D.40917 = cfg->real_offset;
      bblock->real_offset = D.40917;
      <D.40956>:
      ip.331 = ip;
      ip.335 = ip.331 + 5;
      ip = ip.335;
      ip.331 = ip;
      if (ip.331 < end) goto <D.40972>; else goto <D.40973>;
      <D.40972>:
      D.40883 = cfg->cil_offset_to_bb;
      ip.331 = ip;
      ip.332 = (long int) ip.331;
      D.40885 = cfg->cil_start;
      D.40886 = (long int) D.40885;
      D.40920 = ip.332 - D.40886;
      D.40921 = (long unsigned int) D.40920;
      D.40922 = D.40921 * 8;
      D.40923 = D.40883 + D.40922;
      bblock = *D.40923;
      if (bblock == 0B) goto <D.40974>; else goto <D.40975>;
      <D.40974>:
      ip.331 = ip;
      if (ip.331 >= end) goto <D.40976>; else goto <D.40978>;
      <D.40978>:
      D.40896 = header->code;
      ip.331 = ip;
      if (D.40896 > ip.331) goto <D.40976>; else goto <D.40977>;
      <D.40976>:
      D.40862 = cfg->gsharedvt;
      if (D.40862 != 0) goto <D.40979>; else goto <D.40980>;
      <D.40979>:
      D.40865 = cfg->verbose_level;
      if (D.40865 > 2) goto <D.40981>; else goto <D.40982>;
      <D.40981>:
      printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
      <D.40982>:
      mono_cfg_set_exception (cfg, 11);
      goto exception_exit;
      <D.40980>:
      D.40983 = mini_get_debug_options ();
      D.40984 = D.40983->break_on_unverified;
      if (D.40984 != 0) goto <D.40985>; else goto unverified;
      <D.40985>:
      raise (5);
      <D.40977>:
      D.40904 = cfg->mempool;
      bblock = mono_mempool_alloc0 (D.40904, 296);
      D.40905 = cfg->num_bblocks;
      D.40986 = D.40905;
      D.40987 = D.40986 + 1;
      cfg->num_bblocks = D.40987;
      D.40988 = (int) D.40986;
      bblock->block_num = D.40988;
      ip.331 = ip;
      bblock->cil_code = ip.331;
      D.40909 = bblock->cil_code;
      if (D.40909 != 0B) goto <D.40989>; else goto <D.40990>;
      <D.40989>:
      D.40883 = cfg->cil_offset_to_bb;
      D.40909 = bblock->cil_code;
      D.40912 = (long int) D.40909;
      D.40885 = cfg->cil_start;
      D.40886 = (long int) D.40885;
      D.40913 = D.40912 - D.40886;
      D.40914 = (long unsigned int) D.40913;
      D.40915 = D.40914 * 8;
      D.40916 = D.40883 + D.40915;
      *D.40916 = bblock;
      <D.40990>:
      D.40917 = cfg->real_offset;
      bblock->real_offset = D.40917;
      <D.40975>:
      <D.40973>:
      goto <D.27054>;
      <D.27068>:
      {
        guint32 n;
        guint32 j;

        ip.331 = ip;
        ip.334 = ip.331 + 1;
        D.40941 = MEM[(const guint32 *)ip.334];
        D.40942 = D.40941 << 24;
        ip.331 = ip;
        ip.334 = ip.331 + 1;
        D.40941 = MEM[(const guint32 *)ip.334];
        D.40943 = D.40941 >> 8;
        D.40944 = D.40943 & 65280;
        D.40945 = D.40942 | D.40944;
        ip.331 = ip;
        ip.334 = ip.331 + 1;
        D.40941 = MEM[(const guint32 *)ip.334];
        D.40946 = D.40941 << 8;
        D.40947 = D.40946 & 16711680;
        D.40948 = D.40945 | D.40947;
        ip.331 = ip;
        ip.334 = ip.331 + 1;
        D.40941 = MEM[(const guint32 *)ip.334];
        D.40949 = D.40941 >> 24;
        n = D.40948 | D.40949;
        ip.331 = ip;
        ip.335 = ip.331 + 5;
        ip = ip.335;
        D.40991 = n * 4;
        D.40992 = D.40991 + cli_addr;
        cli_addr = D.40992 + 5;
        D.40877 = (sizetype) cli_addr;
        target = start + D.40877;
        D.40883 = cfg->cil_offset_to_bb;
        target.338 = (long int) target;
        D.40885 = cfg->cil_start;
        D.40886 = (long int) D.40885;
        D.40887 = target.338 - D.40886;
        D.40888 = (long unsigned int) D.40887;
        D.40889 = D.40888 * 8;
        D.40890 = D.40883 + D.40889;
        bblock = *D.40890;
        if (bblock == 0B) goto <D.40993>; else goto <D.40994>;
        <D.40993>:
        if (target >= end) goto <D.40995>; else goto <D.40997>;
        <D.40997>:
        D.40896 = header->code;
        if (D.40896 > target) goto <D.40995>; else goto <D.40996>;
        <D.40995>:
        D.40862 = cfg->gsharedvt;
        if (D.40862 != 0) goto <D.40998>; else goto <D.40999>;
        <D.40998>:
        D.40865 = cfg->verbose_level;
        if (D.40865 > 2) goto <D.41000>; else goto <D.41001>;
        <D.41000>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.41001>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.40999>:
        D.41002 = mini_get_debug_options ();
        D.41003 = D.41002->break_on_unverified;
        if (D.41003 != 0) goto <D.41004>; else goto unverified;
        <D.41004>:
        raise (5);
        <D.40996>:
        D.40904 = cfg->mempool;
        bblock = mono_mempool_alloc0 (D.40904, 296);
        D.40905 = cfg->num_bblocks;
        D.41005 = D.40905;
        D.41006 = D.41005 + 1;
        cfg->num_bblocks = D.41006;
        D.41007 = (int) D.41005;
        bblock->block_num = D.41007;
        bblock->cil_code = target;
        D.40909 = bblock->cil_code;
        if (D.40909 != 0B) goto <D.41008>; else goto <D.41009>;
        <D.41008>:
        D.40883 = cfg->cil_offset_to_bb;
        D.40909 = bblock->cil_code;
        D.40912 = (long int) D.40909;
        D.40885 = cfg->cil_start;
        D.40886 = (long int) D.40885;
        D.40913 = D.40912 - D.40886;
        D.40914 = (long unsigned int) D.40913;
        D.40915 = D.40914 * 8;
        D.40916 = D.40883 + D.40915;
        *D.40916 = bblock;
        <D.41009>:
        D.40917 = cfg->real_offset;
        bblock->real_offset = D.40917;
        <D.40994>:
        j = 0;
        goto <D.27072>;
        <D.27071>:
        D.40877 = (sizetype) cli_addr;
        ip.331 = ip;
        D.41010 = MEM[(const guint32 *)ip.331];
        D.41011 = D.41010 << 24;
        ip.331 = ip;
        D.41010 = MEM[(const guint32 *)ip.331];
        D.41012 = D.41010 >> 8;
        D.41013 = D.41012 & 65280;
        D.41014 = D.41011 | D.41013;
        ip.331 = ip;
        D.41010 = MEM[(const guint32 *)ip.331];
        D.41015 = D.41010 << 8;
        D.41016 = D.41015 & 16711680;
        D.41017 = D.41014 | D.41016;
        ip.331 = ip;
        D.41010 = MEM[(const guint32 *)ip.331];
        D.41018 = D.41010 >> 24;
        D.41019 = D.41017 | D.41018;
        D.41020 = (int) D.41019;
        D.41021 = (sizetype) D.41020;
        D.41022 = D.40877 + D.41021;
        target = start + D.41022;
        D.40883 = cfg->cil_offset_to_bb;
        target.338 = (long int) target;
        D.40885 = cfg->cil_start;
        D.40886 = (long int) D.40885;
        D.40887 = target.338 - D.40886;
        D.40888 = (long unsigned int) D.40887;
        D.40889 = D.40888 * 8;
        D.40890 = D.40883 + D.40889;
        bblock = *D.40890;
        if (bblock == 0B) goto <D.41023>; else goto <D.41024>;
        <D.41023>:
        if (target >= end) goto <D.41025>; else goto <D.41027>;
        <D.41027>:
        D.40896 = header->code;
        if (D.40896 > target) goto <D.41025>; else goto <D.41026>;
        <D.41025>:
        D.40862 = cfg->gsharedvt;
        if (D.40862 != 0) goto <D.41028>; else goto <D.41029>;
        <D.41028>:
        D.40865 = cfg->verbose_level;
        if (D.40865 > 2) goto <D.41030>; else goto <D.41031>;
        <D.41030>:
        printf ("gsharedvt method failed to verify, falling back to instantiation.\n");
        <D.41031>:
        mono_cfg_set_exception (cfg, 11);
        goto exception_exit;
        <D.41029>:
        D.41032 = mini_get_debug_options ();
        D.41033 = D.41032->break_on_unverified;
        if (D.41033 != 0) goto <D.41034>; else goto unverified;
        <D.41034>:
        raise (5);
        <D.41026>:
        D.40904 = cfg->mempool;
        bblock = mono_mempool_alloc0 (D.40904, 296);
        D.40905 = cfg->num_bblocks;
        D.41035 = D.40905;
        D.41036 = D.41035 + 1;
        cfg->num_bblocks = D.41036;
        D.41037 = (int) D.41035;
        bblock->block_num = D.41037;
        bblock->cil_code = target;
        D.40909 = bblock->cil_code;
        if (D.40909 != 0B) goto <D.41038>; else goto <D.41039>;
        <D.41038>:
        D.40883 = cfg->cil_offset_to_bb;
        D.40909 = bblock->cil_code;
        D.40912 = (long int) D.40909;
        D.40885 = cfg->cil_start;
        D.40886 = (long int) D.40885;
        D.40913 = D.40912 - D.40886;
        D.40914 = (long unsigned int) D.40913;
        D.40915 = D.40914 * 8;
        D.40916 = D.40883 + D.40915;
        *D.40916 = bblock;
        <D.41039>:
        D.40917 = cfg->real_offset;
        bblock->real_offset = D.40917;
        <D.41024>:
        ip.331 = ip;
        ip.339 = ip.331 + 4;
        ip = ip.339;
        j = j + 1;
        <D.27072>:
        if (j < n) goto <D.27071>; else goto <D.27073>;
        <D.27073>:
        goto <D.27054>;
      }
      <D.27074>:
      <D.27075>:
      ip.331 = ip;
      ip.340 = ip.331 + 9;
      ip = ip.340;
      goto <D.27054>;
      <D.27076>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 6056);
      <D.27054>:
      if (i == 122) goto <D.41042>; else goto <D.41043>;
      <D.41042>:
      {
        unsigned char * bb_start;

        ip.331 = ip;
        bb_start = ip.331 + 18446744073709551615;
        bblock = 0B;
        goto <D.27079>;
        <D.27078>:
        D.40883 = cfg->cil_offset_to_bb;
        bb_start.341 = (long int) bb_start;
        start.333 = (long int) start;
        D.41045 = bb_start.341 - start.333;
        D.41046 = (long unsigned int) D.41045;
        D.41047 = D.41046 * 8;
        D.41048 = D.40883 + D.41047;
        bblock = *D.41048;
        bb_start = bb_start + 18446744073709551615;
        <D.27079>:
        if (bb_start >= start) goto <D.41049>; else goto <D.27080>;
        <D.41049>:
        if (bblock == 0B) goto <D.27078>; else goto <D.27080>;
        <D.27080>:
        if (bblock != 0B) goto <D.41050>; else goto <D.41051>;
        <D.41050>:
        bblock->out_of_line = 1;
        <D.41051>:
      }
      <D.41043>:
      <D.27082>:
      ip.331 = ip;
      if (ip.331 < end) goto <D.27081>; else goto <D.27083>;
      <D.27083>:
      D.41052 = 0;
      return D.41052;
      unverified:
      exception_exit:
      ip.331 = ip;
      *pos = ip.331;
      D.41052 = 1;
      return D.41052;
    }
  finally
    {
      ip = {CLOBBER};
    }
}


should_insert_brekpoint (struct MonoMethod * method)
{
  MonoBreakPolicy (*<T36cf>) (struct MonoMethod *) break_policy_func.342;
  <unnamed type> D.41056;
  gboolean D.41057;

  break_policy_func.342 = break_policy_func;
  D.41056 = break_policy_func.342 (method);
  switch (D.41056) <default: <D.26748>, case 0: <D.26745>, case 1: <D.26746>, case 2: <D.26747>>
  <D.26745>:
  D.41057 = 1;
  return D.41057;
  <D.26746>:
  D.41057 = 0;
  return D.41057;
  <D.26747>:
  monoeg_g_log (0B, 16, "mdb no longer supported");
  D.41057 = 0;
  return D.41057;
  <D.26748>:
  monoeg_g_log (0B, 16, "Incorrect value returned from break policy callback");
  D.41057 = 0;
  return D.41057;
}


mini_get_signature (struct MonoMethod * method, guint32 token, struct MonoGenericContext * context)
{
  long unsigned int D.41059;
  long unsigned int D.41060;
  int D.41065;
  _Bool D.41066;
  long int D.41067;
  long int D.41068;
  struct MonoClass * D.41072;
  struct MonoImage * D.41073;
  struct MonoMethodSignature * D.41074;
  struct MonoMethodSignature * fsig;

  D.41059 = BIT_FIELD_REF <*method, 64, 256>;
  D.41060 = D.41059 & 4467570830351532032;
  if (D.41060 != 0) goto <D.41061>; else goto <D.41062>;
  <D.41061>:
  {
    struct MonoError error;

    try
      {
        fsig = mono_method_get_wrapper_data (method, token);
        if (context != 0B) goto <D.41063>; else goto <D.41064>;
        <D.41063>:
        fsig = mono_inflate_generic_signature (fsig, context, &error);
        D.41065 = mono_error_ok (&error);
        D.41066 = D.41065 == 0;
        D.41067 = (long int) D.41066;
        D.41068 = __builtin_expect (D.41067, 0);
        if (D.41068 != 0) goto <D.41069>; else goto <D.41070>;
        <D.41069>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6135, "mono_error_ok (&error)");
        <D.41070>:
        <D.41064>:
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  goto <D.41071>;
  <D.41062>:
  D.41072 = method->klass;
  D.41073 = D.41072->image;
  fsig = mono_metadata_parse_signature (D.41073, token);
  <D.41071>:
  D.41074 = fsig;
  return D.41074;
}


mini_get_method_allow_open (struct MonoMethod * m, guint32 token, struct MonoClass * klass, struct MonoGenericContext * context)
{
  long unsigned int D.41076;
  long unsigned int D.41077;
  struct MonoClass * D.41083;
  struct MonoImage * D.41084;
  struct MonoMethod * D.41085;
  struct MonoMethod * method;

  D.41076 = BIT_FIELD_REF <*m, 64, 256>;
  D.41077 = D.41076 & 4467570830351532032;
  if (D.41077 != 0) goto <D.41078>; else goto <D.41079>;
  <D.41078>:
  method = mono_method_get_wrapper_data (m, token);
  if (context != 0B) goto <D.41080>; else goto <D.41081>;
  <D.41080>:
  method = mono_class_inflate_generic_method (method, context);
  <D.41081>:
  goto <D.41082>;
  <D.41079>:
  D.41083 = m->klass;
  D.41084 = D.41083->image;
  method = mono_get_method_full (D.41084, token, klass, context);
  <D.41082>:
  D.41085 = method;
  return D.41085;
}


mini_emit_inst_for_sharable_method (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, struct MonoInst * * args)
{
  struct MonoClass * D.41087;
  struct MonoClass * D.41088;
  const char * D.41091;
  int D.41092;
  struct MonoInst * D.41095;
  int D.41096;

  D.41087 = cmethod->klass;
  D.41088 = mono_defaults.array_class;
  if (D.41087 == D.41088) goto <D.41089>; else goto <D.41090>;
  <D.41089>:
  D.41091 = cmethod->name;
  D.41092 = strcmp (D.41091, "UnsafeStore");
  if (D.41092 == 0) goto <D.41093>; else goto <D.41094>;
  <D.41093>:
  D.41095 = emit_array_unsafe_access (cfg, fsig, args, 1);
  return D.41095;
  <D.41094>:
  D.41091 = cmethod->name;
  D.41096 = strcmp (D.41091, "UnsafeLoad");
  if (D.41096 == 0) goto <D.41097>; else goto <D.41098>;
  <D.41097>:
  D.41095 = emit_array_unsafe_access (cfg, fsig, args, 0);
  return D.41095;
  <D.41098>:
  <D.41090>:
  D.41095 = 0B;
  return D.41095;
}


emit_array_unsafe_access (struct MonoCompile * cfg, struct MonoMethodSignature * fsig, struct MonoInst * * args, int is_set)
{
  struct MonoType * D.41102;
  struct MonoType * D.41104;
  struct MonoInst * D.41107;
  struct MonoInst * D.41108;
  struct MonoInst * * D.41109;
  struct MonoInst * D.41110;
  struct MonoMemPool * D.41111;
  long int D.41112;
  struct MonoInst * D.41113;
  struct MonoType * D.41114;
  unsigned int D.41115;
  short unsigned int D.41116;
  int D.41117;
  int D.41118;
  const unsigned char * D.41119;
  int D.41120;
  unsigned char D.41121;
  <unnamed type> D.41122;
  unsigned int D.41123;
  int D.41124;
  struct MonoBasicBlock * D.41125;
  struct MonoInst * D.41126;
  struct MonoClass * eklass;

  if (is_set != 0) goto <D.41100>; else goto <D.41101>;
  <D.41100>:
  D.41102 = fsig->params[2];
  eklass = mono_class_from_mono_type (D.41102);
  goto <D.41103>;
  <D.41101>:
  D.41104 = fsig->ret;
  eklass = mono_class_from_mono_type (D.41104);
  <D.41103>:
  if (is_set != 0) goto <D.41105>; else goto <D.41106>;
  <D.41105>:
  D.41107 = emit_array_store (cfg, eklass, args, 0);
  return D.41107;
  <D.41106>:
  {
    struct MonoInst * ins;
    struct MonoInst * addr;

    D.41108 = *args;
    D.41109 = args + 8;
    D.41110 = *D.41109;
    addr = mini_emit_ldelema_1_ins (cfg, eklass, D.41108, D.41110, 0);
    D.41111 = cfg->mempool;
    ins = mono_mempool_alloc (D.41111, 80);
    ins->data.op[1].const_val = 0;
    D.41112 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.41112;
    ins->prev = 0B;
    D.41113 = ins->prev;
    ins->next = D.41113;
    D.41114 = &eklass->byval_arg;
    D.41115 = mono_type_to_load_membase (cfg, D.41114);
    D.41116 = (short unsigned int) D.41115;
    ins->opcode = D.41116;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.41117 = ins->sreg3;
    ins->sreg2 = D.41117;
    D.41118 = ins->sreg2;
    ins->sreg1 = D.41118;
    D.41119 = cfg->ip;
    ins->cil_code = D.41119;
    ins->dreg = 0;
    D.41120 = addr->dreg;
    ins->sreg1 = D.41120;
    ins->data.op[0].const_val = 0;
    ins->type = 1;
    D.41114 = &eklass->byval_arg;
    type_to_eval_stack_type (cfg, D.41114, ins);
    D.41121 = ins->type;
    D.41122 = (<unnamed type>) D.41121;
    D.41123 = alloc_dreg (cfg, D.41122);
    D.41124 = (int) D.41123;
    ins->dreg = D.41124;
    D.41125 = cfg->cbb;
    D.41126 = D.41125->last_ins;
    if (D.41126 != 0B) goto <D.41127>; else goto <D.41128>;
    <D.41127>:
    D.41125 = cfg->cbb;
    D.41126 = D.41125->last_ins;
    D.41126->next = ins;
    D.41125 = cfg->cbb;
    D.41126 = D.41125->last_ins;
    ins->prev = D.41126;
    D.41125 = cfg->cbb;
    D.41125->last_ins = ins;
    goto <D.41129>;
    <D.41128>:
    D.41125 = cfg->cbb;
    D.41125 = cfg->cbb;
    D.41125->last_ins = ins;
    D.41126 = D.41125->last_ins;
    D.41125->code = D.41126;
    <D.41129>:
    D.41107 = ins;
    return D.41107;
  }
}


check_method_sharing (struct MonoCompile * cfg, struct MonoMethod * cmethod, gboolean * out_pass_vtable, gboolean * out_pass_mrgctx)
{
  short unsigned int D.41134;
  int D.41135;
  int D.41136;
  struct MonoClass * D.41138;
  long unsigned int D.41139;
  long unsigned int D.41140;
  struct MonoGenericClass * D.41141;
  struct MonoGenericContainer * D.41143;
  int D.41144;
  int iftmp.343;
  struct MonoGenericContext * D.41157;
  struct MonoGenericContext * D.41159;
  struct MonoGenericInst * D.41160;
  struct MonoGenericContext * D.41161;
  struct MonoGenericContext * D.41164;
  struct MonoGenericInst * D.41165;
  _Bool D.41168;
  long int D.41169;
  long int D.41170;
  int D.41173;
  int D.41181;
  struct MonoMethodSignature * D.41184;
  int D.41185;
  gboolean pass_vtable;
  gboolean pass_mrgctx;

  pass_vtable = 0;
  pass_mrgctx = 0;
  D.41134 = cmethod->flags;
  D.41135 = (int) D.41134;
  D.41136 = D.41135 & 16;
  if (D.41136 != 0) goto <D.41133>; else goto <D.41137>;
  <D.41137>:
  D.41138 = cmethod->klass;
  D.41139 = BIT_FIELD_REF <*D.41138, 64, 256>;
  D.41140 = D.41139 & 1152921504606846976;
  if (D.41140 != 0) goto <D.41133>; else goto <D.41132>;
  <D.41133>:
  D.41138 = cmethod->klass;
  D.41141 = D.41138->generic_class;
  if (D.41141 != 0B) goto <D.41131>; else goto <D.41142>;
  <D.41142>:
  D.41138 = cmethod->klass;
  D.41143 = D.41138->generic_container;
  if (D.41143 != 0B) goto <D.41131>; else goto <D.41132>;
  <D.41131>:
  {
    gboolean sharable;

    sharable = 0;
    D.41144 = mono_method_is_generic_sharable (cmethod, 1);
    if (D.41144 != 0) goto <D.41145>; else goto <D.41146>;
    <D.41145>:
    sharable = 1;
    goto <D.41147>;
    <D.41146>:
    {
      gboolean sharing_enabled;
      struct MonoGenericContext * context;
      gboolean context_sharable;

      D.41138 = cmethod->klass;
      sharing_enabled = mono_class_generic_sharing_enabled (D.41138);
      D.41138 = cmethod->klass;
      context = mini_class_get_context (D.41138);
      context_sharable = mono_generic_context_is_sharable (context, 1);
      if (sharing_enabled != 0) goto <D.41151>; else goto <D.41149>;
      <D.41151>:
      if (context_sharable != 0) goto <D.41152>; else goto <D.41149>;
      <D.41152>:
      iftmp.343 = 1;
      goto <D.41150>;
      <D.41149>:
      iftmp.343 = 0;
      <D.41150>:
      sharable = iftmp.343;
    }
    <D.41147>:
    if (sharable != 0) goto <D.41155>; else goto <D.41156>;
    <D.41155>:
    D.41157 = mini_method_get_context (cmethod);
    if (D.41157 == 0B) goto <D.41153>; else goto <D.41158>;
    <D.41158>:
    D.41159 = mini_method_get_context (cmethod);
    D.41160 = D.41159->method_inst;
    if (D.41160 == 0B) goto <D.41153>; else goto <D.41154>;
    <D.41153>:
    pass_vtable = 1;
    <D.41154>:
    <D.41156>:
  }
  <D.41132>:
  D.41161 = mini_method_get_context (cmethod);
  if (D.41161 != 0B) goto <D.41162>; else goto <D.41163>;
  <D.41162>:
  D.41164 = mini_method_get_context (cmethod);
  D.41165 = D.41164->method_inst;
  if (D.41165 != 0B) goto <D.41166>; else goto <D.41167>;
  <D.41166>:
  D.41168 = pass_vtable != 0;
  D.41169 = (long int) D.41168;
  D.41170 = __builtin_expect (D.41169, 0);
  if (D.41170 != 0) goto <D.41171>; else goto <D.41172>;
  <D.41171>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 2418, "!pass_vtable");
  <D.41172>:
  D.41173 = mono_method_is_generic_sharable (cmethod, 1);
  if (D.41173 != 0) goto <D.41174>; else goto <D.41175>;
  <D.41174>:
  pass_mrgctx = 1;
  goto <D.41176>;
  <D.41175>:
  {
    gboolean sharing_enabled;
    struct MonoGenericContext * context;
    gboolean context_sharable;

    D.41138 = cmethod->klass;
    sharing_enabled = mono_class_generic_sharing_enabled (D.41138);
    context = mini_method_get_context (cmethod);
    context_sharable = mono_generic_context_is_sharable (context, 1);
    if (sharing_enabled != 0) goto <D.41177>; else goto <D.41178>;
    <D.41177>:
    if (context_sharable != 0) goto <D.41179>; else goto <D.41180>;
    <D.41179>:
    pass_mrgctx = 1;
    <D.41180>:
    <D.41178>:
    D.41181 = cfg->gsharedvt;
    if (D.41181 != 0) goto <D.41182>; else goto <D.41183>;
    <D.41182>:
    D.41184 = mono_method_signature (cmethod);
    D.41185 = mini_is_gsharedvt_signature (cfg, D.41184);
    if (D.41185 != 0) goto <D.41186>; else goto <D.41187>;
    <D.41186>:
    pass_mrgctx = 1;
    <D.41187>:
    <D.41183>:
  }
  <D.41176>:
  <D.41167>:
  <D.41163>:
  if (out_pass_vtable != 0B) goto <D.41188>; else goto <D.41189>;
  <D.41188>:
  *out_pass_vtable = pass_vtable;
  <D.41189>:
  if (out_pass_mrgctx != 0B) goto <D.41190>; else goto <D.41191>;
  <D.41190>:
  *out_pass_mrgctx = pass_mrgctx;
  <D.41191>:
}


type_from_stack_type (struct MonoInst * ins)
{
  unsigned char D.41192;
  int D.41193;
  struct MonoType * D.41194;
  struct MonoClass * D.41195;
  struct MonoClass * D.41196;
  struct MonoClass * D.41197;
  struct MonoClass * D.41198;
  struct MonoClass * D.41199;
  struct MonoClass * D.41200;

  D.41192 = ins->type;
  D.41193 = (int) D.41192;
  switch (D.41193) <default: <D.25286>, case 1: <D.25279>, case 2: <D.25280>, case 3: <D.25281>, case 4: <D.25282>, case 5: <D.25283>, case 6: <D.25284>, case 7: <D.25285>>
  <D.25279>:
  D.41195 = mono_defaults.int32_class;
  D.41194 = &D.41195->byval_arg;
  return D.41194;
  <D.25280>:
  D.41196 = mono_defaults.int64_class;
  D.41194 = &D.41196->byval_arg;
  return D.41194;
  <D.25281>:
  D.41197 = mono_defaults.int_class;
  D.41194 = &D.41197->byval_arg;
  return D.41194;
  <D.25282>:
  D.41198 = mono_defaults.double_class;
  D.41194 = &D.41198->byval_arg;
  return D.41194;
  <D.25283>:
  D.41199 = ins->klass;
  D.41194 = &D.41199->this_arg;
  return D.41194;
  <D.25284>:
  D.41200 = mono_defaults.object_class;
  D.41194 = &D.41200->byval_arg;
  return D.41194;
  <D.25285>:
  D.41199 = ins->klass;
  D.41194 = &D.41199->byval_arg;
  return D.41194;
  <D.25286>:
  D.41192 = ins->type;
  D.41193 = (int) D.41192;
  monoeg_g_log (0B, 4, "stack type %d to monotype not handled\n", D.41193);
  <D.25287>:
  goto <D.25287>;
  D.41194 = 0B;
  return D.41194;
}


mini_emit_inst_for_method (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, struct MonoInst * * args)
{
  struct MonoClass * runtime_helpers_class.344;
  struct MonoImage * D.41205;
  struct MonoClass * runtime_helpers_class.345;
  struct MonoClass * D.41207;
  struct MonoClass * D.41208;
  const char * D.41211;
  int D.41212;
  unsigned int D.41215;
  unsigned int D.41216;
  unsigned int D.41217;
  unsigned int D.41218;
  struct MonoMemPool * D.41219;
  long int D.41220;
  struct MonoInst * D.41221;
  int D.41222;
  int D.41223;
  const unsigned char * D.41224;
  struct MonoInst * * D.41225;
  struct MonoInst * D.41226;
  int D.41227;
  struct MonoBasicBlock * D.41228;
  struct MonoInst * D.41229;
  unsigned int D.41233;
  unsigned int D.41234;
  unsigned int D.41237;
  long unsigned int D.41240;
  long unsigned int D.41241;
  long int D.41244;
  struct MonoInst * D.41245;
  int D.41246;
  int D.41247;
  struct MonoInst * D.41248;
  int D.41249;
  long int D.41253;
  struct MonoInst * D.41254;
  int D.41255;
  int D.41256;
  unsigned int D.41263;
  int D.41266;
  long int D.41271;
  struct MonoInst * D.41272;
  int D.41273;
  int D.41274;
  long int D.41278;
  struct MonoInst * D.41279;
  int D.41280;
  int D.41281;
  long int D.41286;
  struct MonoInst * D.41287;
  int D.41288;
  int D.41289;
  unsigned char D.41290;
  int D.41295;
  long int D.41300;
  struct MonoInst * D.41301;
  int D.41302;
  int D.41303;
  long int D.41307;
  struct MonoInst * D.41308;
  int D.41309;
  int D.41310;
  long int D.41315;
  struct MonoInst * D.41316;
  int D.41317;
  int D.41318;
  unsigned char D.41319;
  long int D.41323;
  struct MonoInst * D.41324;
  int D.41325;
  int D.41326;
  long int D.41330;
  struct MonoInst * D.41331;
  int D.41332;
  int D.41333;
  unsigned int D.41338;
  int D.41341;
  long int D.41346;
  struct MonoInst * D.41347;
  int D.41348;
  int D.41349;
  long int D.41353;
  struct MonoInst * D.41354;
  int D.41355;
  int D.41356;
  long int D.41361;
  struct MonoInst * D.41362;
  int D.41363;
  int D.41364;
  unsigned char D.41365;
  int D.41370;
  long int D.41375;
  struct MonoInst * D.41376;
  int D.41377;
  int D.41378;
  long int D.41382;
  struct MonoInst * D.41383;
  int D.41384;
  int D.41385;
  long int D.41390;
  struct MonoInst * D.41391;
  int D.41392;
  int D.41393;
  unsigned char D.41394;
  long int D.41398;
  struct MonoInst * D.41399;
  int D.41400;
  int D.41401;
  long int D.41405;
  struct MonoInst * D.41406;
  int D.41407;
  int D.41408;
  long int D.41413;
  struct MonoInst * D.41414;
  int D.41415;
  int D.41416;
  unsigned char D.41417;
  unsigned char D.41418;
  unsigned int D.41422;
  unsigned int D.41423;
  long int D.41424;
  struct MonoInst * D.41425;
  int D.41426;
  int D.41427;
  long int D.41431;
  struct MonoInst * D.41432;
  int D.41433;
  int D.41434;
  long int D.41438;
  struct MonoInst * D.41439;
  int D.41440;
  int D.41441;
  struct MonoInst * D.41445;
  int D.41446;
  unsigned int D.41449;
  unsigned char D.41453;
  unsigned char D.41454;
  int D.41455;
  unsigned int D.41458;
  unsigned int D.41459;
  long int D.41460;
  struct MonoInst * D.41461;
  int D.41462;
  int D.41463;
  long int D.41467;
  struct MonoInst * D.41468;
  int D.41469;
  int D.41470;
  long int D.41474;
  struct MonoInst * D.41475;
  int D.41476;
  int D.41477;
  struct MonoInst * * D.41478;
  struct MonoInst * D.41479;
  int D.41480;
  struct MonoClass * D.41484;
  int D.41487;
  unsigned int D.41490;
  unsigned int D.41491;
  int D.41492;
  long int D.41497;
  struct MonoInst * D.41498;
  int D.41499;
  int D.41500;
  long int D.41504;
  struct MonoInst * D.41505;
  int D.41506;
  int D.41507;
  long int D.41512;
  struct MonoInst * D.41513;
  int D.41514;
  int D.41515;
  unsigned char D.41516;
  int D.41524;
  int D.41526;
  unsigned int D.41528;
  unsigned int D.41529;
  long int D.41530;
  struct MonoInst * D.41531;
  int D.41532;
  int D.41533;
  int D.41540;
  struct MonoClass * D.41546;
  int D.41549;
  const char * D.41552;
  int D.41553;
  char D.41556;
  _Bool D.41557;
  int D.41558;
  int D.41561;
  int D.41563;
  short unsigned int D.41564;
  long int D.41567;
  unsigned int D.41570;
  unsigned int D.41571;
  int D.41572;
  _Bool D.41573;
  unsigned int D.41574;
  unsigned int D.41575;
  unsigned int D.41576;
  int D.41577;
  unsigned int D.41578;
  unsigned int D.41579;
  int D.41580;
  int D.41581;
  long int D.41586;
  struct MonoInst * D.41587;
  int D.41588;
  int D.41589;
  long int D.41593;
  struct MonoInst * D.41594;
  int D.41595;
  int D.41596;
  unsigned char D.41601;
  long int D.41605;
  struct MonoInst * D.41606;
  int D.41607;
  int D.41608;
  long int D.41612;
  struct MonoInst * D.41613;
  int D.41614;
  int D.41615;
  unsigned int D.41618;
  unsigned int D.41619;
  int D.41620;
  unsigned char * D.41624;
  struct MonoBasicBlock * * D.41627;
  long int D.41628;
  unsigned char * D.41629;
  long int D.41630;
  long int D.41631;
  long unsigned int D.41632;
  long unsigned int D.41633;
  struct MonoBasicBlock * * D.41634;
  unsigned int D.41635;
  short unsigned int D.41640;
  short unsigned int D.41641;
  short unsigned int D.41643;
  short unsigned int D.41645;
  struct MonoBasicBlock * * D.41646;
  struct MonoBasicBlock * * D.41647;
  struct MonoBasicBlock * D.41648;
  void * D.41658;
  struct MonoBasicBlock * * D.41659;
  struct MonoBasicBlock * * D.41660;
  long unsigned int D.41664;
  long unsigned int D.41665;
  unsigned int D.41668;
  unsigned int D.41669;
  int D.41670;
  long int D.41697;
  struct MonoInst * D.41698;
  int D.41699;
  int D.41700;
  unsigned int D.41703;
  unsigned int D.41704;
  int D.41705;
  unsigned char * D.41709;
  long int D.41712;
  long int D.41713;
  long unsigned int D.41714;
  long unsigned int D.41715;
  struct MonoBasicBlock * * D.41716;
  void * D.41732;
  struct MonoBasicBlock * * D.41733;
  struct MonoBasicBlock * * D.41734;
  unsigned int D.41740;
  unsigned int D.41741;
  int D.41742;
  unsigned char * D.41760;
  long int D.41763;
  long int D.41764;
  long unsigned int D.41765;
  long unsigned int D.41766;
  struct MonoBasicBlock * * D.41767;
  long int D.41788;
  struct MonoInst * D.41789;
  int D.41790;
  int D.41791;
  unsigned char * D.41795;
  long int D.41798;
  long int D.41799;
  long unsigned int D.41800;
  long unsigned int D.41801;
  struct MonoBasicBlock * * D.41802;
  int D.41822;
  unsigned int D.41825;
  unsigned int D.41826;
  int D.41827;
  long int D.41832;
  struct MonoInst * D.41833;
  int D.41834;
  int D.41835;
  long int D.41839;
  struct MonoInst * D.41840;
  int D.41841;
  int D.41842;
  long int D.41847;
  struct MonoInst * D.41848;
  int D.41849;
  int D.41850;
  unsigned char D.41851;
  int D.41858;
  unsigned int D.41861;
  int D.41862;
  long int D.41867;
  struct MonoInst * D.41868;
  int D.41869;
  int D.41870;
  long int D.41874;
  struct MonoInst * D.41875;
  int D.41876;
  int D.41877;
  unsigned char D.41882;
  int D.41888;
  unsigned int D.41891;
  int D.41892;
  struct MonoClass * D.41896;
  int D.41899;
  int D.41905;
  struct MonoClass * D.41909;
  struct MonoImage * D.41915;
  const char * D.41917;
  int D.41918;
  const char * D.41920;
  int D.41921;
  int D.41923;
  struct MonoType * D.41926;
  unsigned char D.41927;
  unsigned int D.41930;
  int D.41931;
  int D.41935;
  long int D.41945;
  struct MonoInst * D.41946;
  int D.41947;
  int D.41948;
  unsigned int D.41949;
  int D.41950;
  short unsigned int D.41954;
  unsigned int D.41955;
  int D.41956;
  int D.41957;
  guint8 iftmp.346;
  int D.41966;
  long int D.41976;
  struct MonoInst * D.41977;
  int D.41978;
  int D.41979;
  unsigned int D.41980;
  int D.41981;
  short unsigned int D.41985;
  unsigned int D.41986;
  int D.41987;
  int D.41988;
  guint8 iftmp.347;
  int D.41997;
  short unsigned int D.42007;
  unsigned int D.42008;
  int D.42009;
  guint8 iftmp.348;
  int D.42017;
  _Bool D.42020;
  short unsigned int D.42029;
  gint32 iftmp.349;
  unsigned int D.42033;
  unsigned int D.42035;
  int D.42039;
  long unsigned int D.42040;
  int D.42045;
  int D.42054;
  int D.42057;
  struct MonoMethod * D.42060;
  int D.42061;
  int D.42070;
  int D.42073;
  unsigned int D.42076;
  int D.42077;
  struct MonoClass * D.42082;
  struct MonoAssembly * D.42086;
  const char * D.42087;
  int D.42088;
  int D.42091;
  int D.42094;
  int D.42097;
  long unsigned int D.42100;
  short unsigned int D.42103;
  struct MonoInst * ins;
  static struct MonoClass * runtime_helpers_class = 0B;

  ins = 0B;
  runtime_helpers_class.344 = runtime_helpers_class;
  if (runtime_helpers_class.344 == 0B) goto <D.41203>; else goto <D.41204>;
  <D.41203>:
  D.41205 = mono_defaults.corlib;
  runtime_helpers_class.345 = mono_class_from_name (D.41205, "System.Runtime.CompilerServices", "RuntimeHelpers");
  runtime_helpers_class = runtime_helpers_class.345;
  <D.41204>:
  D.41207 = cmethod->klass;
  D.41208 = mono_defaults.string_class;
  if (D.41207 == D.41208) goto <D.41209>; else goto <D.41210>;
  <D.41209>:
  D.41211 = cmethod->name;
  D.41212 = strcmp (D.41211, "get_Chars");
  if (D.41212 == 0) goto <D.41213>; else goto <D.41214>;
  <D.41213>:
  {
    int dreg;
    int index_reg;
    int mult_reg;
    int add_reg;

    D.41215 = alloc_ireg (cfg);
    dreg = (int) D.41215;
    D.41216 = alloc_preg (cfg);
    index_reg = (int) D.41216;
    D.41217 = alloc_preg (cfg);
    mult_reg = (int) D.41217;
    D.41218 = alloc_preg (cfg);
    add_reg = (int) D.41218;
    {
      struct MonoInst * inst;

      D.41219 = cfg->mempool;
      inst = mono_mempool_alloc (D.41219, 80);
      inst->data.op[1].const_val = 0;
      D.41220 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.41220;
      inst->prev = 0B;
      D.41221 = inst->prev;
      inst->next = D.41221;
      inst->opcode = 762;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.41222 = inst->sreg3;
      inst->sreg2 = D.41222;
      D.41223 = inst->sreg2;
      inst->sreg1 = D.41223;
      D.41224 = cfg->ip;
      inst->cil_code = D.41224;
      inst->dreg = index_reg;
      D.41225 = args + 8;
      D.41226 = *D.41225;
      D.41227 = D.41226->dreg;
      inst->sreg1 = D.41227;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41230>; else goto <D.41231>;
      <D.41230>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41229->next = inst;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      inst->prev = D.41229;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      goto <D.41232>;
      <D.41231>:
      D.41228 = cfg->cbb;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      D.41229 = D.41228->last_ins;
      D.41228->code = D.41229;
      <D.41232>:
    }
    D.41233 = cfg->opt;
    D.41234 = D.41233 & 134217728;
    if (D.41234 == 0) goto <D.41235>; else goto <D.41236>;
    <D.41235>:
    D.41233 = cfg->opt;
    D.41237 = D.41233 & 262144;
    if (D.41237 == 0) goto <D.41238>; else goto <D.41239>;
    <D.41238>:
    D.41240 = BIT_FIELD_REF <*cfg, 64, 5632>;
    D.41241 = D.41240 & 144115188075855872;
    if (D.41241 != 0) goto <D.41242>; else goto <D.41243>;
    <D.41242>:
    {
      struct MonoInst * inst;

      D.41219 = cfg->mempool;
      inst = mono_mempool_alloc (D.41219, 80);
      inst->data.op[1].const_val = 0;
      D.41244 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.41244;
      inst->prev = 0B;
      D.41245 = inst->prev;
      inst->next = D.41245;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.41246 = inst->sreg3;
      inst->sreg2 = D.41246;
      D.41247 = inst->sreg2;
      inst->sreg1 = D.41247;
      D.41224 = cfg->ip;
      inst->cil_code = D.41224;
      inst->dreg = -1;
      D.41248 = *args;
      D.41249 = D.41248->dreg;
      inst->sreg1 = D.41249;
      inst->data.op[1].const_val = 0;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41250>; else goto <D.41251>;
      <D.41250>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41229->next = inst;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      inst->prev = D.41229;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      goto <D.41252>;
      <D.41251>:
      D.41228 = cfg->cbb;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      D.41229 = D.41228->last_ins;
      D.41228->code = D.41229;
      <D.41252>:
    }
    {
      struct MonoInst * inst;

      D.41219 = cfg->mempool;
      inst = mono_mempool_alloc (D.41219, 80);
      inst->data.op[1].const_val = 0;
      D.41253 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.41253;
      inst->prev = 0B;
      D.41254 = inst->prev;
      inst->next = D.41254;
      inst->opcode = 451;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.41255 = inst->sreg3;
      inst->sreg2 = D.41255;
      D.41256 = inst->sreg2;
      inst->sreg1 = D.41256;
      D.41224 = cfg->ip;
      inst->cil_code = D.41224;
      inst->data.op[1].p = "NullReferenceException";
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41257>; else goto <D.41258>;
      <D.41257>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41229->next = inst;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      inst->prev = D.41229;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      goto <D.41259>;
      <D.41258>:
      D.41228 = cfg->cbb;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      D.41229 = D.41228->last_ins;
      D.41228->code = D.41229;
      <D.41259>:
    }
    goto <D.41260>;
    <D.41243>:
    <D.41260>:
    if (0 != 0) goto <D.41261>; else goto <D.41262>;
    <D.41261>:
    {
      int _length_reg;

      D.41263 = alloc_ireg (cfg);
      _length_reg = (int) D.41263;
      if (1 != 0) goto <D.41264>; else goto <D.41265>;
      <D.41264>:
      {
        struct MonoInst * inst;
        int __ins_flags;

        __ins_flags = 32;
        D.41266 = __ins_flags & 32;
        if (D.41266 != 0) goto <D.41267>; else goto <D.41268>;
        <D.41267>:
        D.41240 = BIT_FIELD_REF <*cfg, 64, 5632>;
        D.41241 = D.41240 & 144115188075855872;
        if (D.41241 != 0) goto <D.41269>; else goto <D.41270>;
        <D.41269>:
        {
          struct MonoInst * inst;

          D.41219 = cfg->mempool;
          inst = mono_mempool_alloc (D.41219, 80);
          inst->data.op[1].const_val = 0;
          D.41271 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.41271;
          inst->prev = 0B;
          D.41272 = inst->prev;
          inst->next = D.41272;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.41273 = inst->sreg3;
          inst->sreg2 = D.41273;
          D.41274 = inst->sreg2;
          inst->sreg1 = D.41274;
          D.41224 = cfg->ip;
          inst->cil_code = D.41224;
          inst->dreg = -1;
          D.41248 = *args;
          D.41249 = D.41248->dreg;
          inst->sreg1 = D.41249;
          inst->data.op[1].const_val = 0;
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          if (D.41229 != 0B) goto <D.41275>; else goto <D.41276>;
          <D.41275>:
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          D.41229->next = inst;
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          inst->prev = D.41229;
          D.41228 = cfg->cbb;
          D.41228->last_ins = inst;
          goto <D.41277>;
          <D.41276>:
          D.41228 = cfg->cbb;
          D.41228 = cfg->cbb;
          D.41228->last_ins = inst;
          D.41229 = D.41228->last_ins;
          D.41228->code = D.41229;
          <D.41277>:
        }
        {
          struct MonoInst * inst;

          D.41219 = cfg->mempool;
          inst = mono_mempool_alloc (D.41219, 80);
          inst->data.op[1].const_val = 0;
          D.41278 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.41278;
          inst->prev = 0B;
          D.41279 = inst->prev;
          inst->next = D.41279;
          inst->opcode = 451;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.41280 = inst->sreg3;
          inst->sreg2 = D.41280;
          D.41281 = inst->sreg2;
          inst->sreg1 = D.41281;
          D.41224 = cfg->ip;
          inst->cil_code = D.41224;
          inst->data.op[1].p = "NullReferenceException";
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          if (D.41229 != 0B) goto <D.41282>; else goto <D.41283>;
          <D.41282>:
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          D.41229->next = inst;
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          inst->prev = D.41229;
          D.41228 = cfg->cbb;
          D.41228->last_ins = inst;
          goto <D.41284>;
          <D.41283>:
          D.41228 = cfg->cbb;
          D.41228 = cfg->cbb;
          D.41228->last_ins = inst;
          D.41229 = D.41228->last_ins;
          D.41228->code = D.41229;
          <D.41284>:
        }
        goto <D.41285>;
        <D.41270>:
        <D.41285>:
        <D.41268>:
        D.41219 = cfg->mempool;
        inst = mono_mempool_alloc (D.41219, 80);
        inst->data.op[1].const_val = 0;
        D.41286 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.41286;
        inst->prev = 0B;
        D.41287 = inst->prev;
        inst->next = D.41287;
        inst->opcode = 393;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.41288 = inst->sreg3;
        inst->sreg2 = D.41288;
        D.41289 = inst->sreg2;
        inst->sreg1 = D.41289;
        D.41224 = cfg->ip;
        inst->cil_code = D.41224;
        inst->dreg = _length_reg;
        D.41248 = *args;
        D.41249 = D.41248->dreg;
        inst->sreg1 = D.41249;
        inst->data.op[0].const_val = 16;
        inst->type = 1;
        D.41290 = (unsigned char) __ins_flags;
        inst->flags = D.41290;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        if (D.41229 != 0B) goto <D.41291>; else goto <D.41292>;
        <D.41291>:
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        D.41229->next = inst;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        inst->prev = D.41229;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        goto <D.41293>;
        <D.41292>:
        D.41228 = cfg->cbb;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        D.41229 = D.41228->last_ins;
        D.41228->code = D.41229;
        <D.41293>:
      }
      goto <D.41294>;
      <D.41265>:
      {
        struct MonoInst * inst;
        int __ins_flags;

        __ins_flags = 64;
        D.41295 = __ins_flags & 32;
        if (D.41295 != 0) goto <D.41296>; else goto <D.41297>;
        <D.41296>:
        D.41240 = BIT_FIELD_REF <*cfg, 64, 5632>;
        D.41241 = D.41240 & 144115188075855872;
        if (D.41241 != 0) goto <D.41298>; else goto <D.41299>;
        <D.41298>:
        {
          struct MonoInst * inst;

          D.41219 = cfg->mempool;
          inst = mono_mempool_alloc (D.41219, 80);
          inst->data.op[1].const_val = 0;
          D.41300 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.41300;
          inst->prev = 0B;
          D.41301 = inst->prev;
          inst->next = D.41301;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.41302 = inst->sreg3;
          inst->sreg2 = D.41302;
          D.41303 = inst->sreg2;
          inst->sreg1 = D.41303;
          D.41224 = cfg->ip;
          inst->cil_code = D.41224;
          inst->dreg = -1;
          D.41248 = *args;
          D.41249 = D.41248->dreg;
          inst->sreg1 = D.41249;
          inst->data.op[1].const_val = 0;
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          if (D.41229 != 0B) goto <D.41304>; else goto <D.41305>;
          <D.41304>:
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          D.41229->next = inst;
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          inst->prev = D.41229;
          D.41228 = cfg->cbb;
          D.41228->last_ins = inst;
          goto <D.41306>;
          <D.41305>:
          D.41228 = cfg->cbb;
          D.41228 = cfg->cbb;
          D.41228->last_ins = inst;
          D.41229 = D.41228->last_ins;
          D.41228->code = D.41229;
          <D.41306>:
        }
        {
          struct MonoInst * inst;

          D.41219 = cfg->mempool;
          inst = mono_mempool_alloc (D.41219, 80);
          inst->data.op[1].const_val = 0;
          D.41307 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.41307;
          inst->prev = 0B;
          D.41308 = inst->prev;
          inst->next = D.41308;
          inst->opcode = 451;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.41309 = inst->sreg3;
          inst->sreg2 = D.41309;
          D.41310 = inst->sreg2;
          inst->sreg1 = D.41310;
          D.41224 = cfg->ip;
          inst->cil_code = D.41224;
          inst->data.op[1].p = "NullReferenceException";
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          if (D.41229 != 0B) goto <D.41311>; else goto <D.41312>;
          <D.41311>:
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          D.41229->next = inst;
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          inst->prev = D.41229;
          D.41228 = cfg->cbb;
          D.41228->last_ins = inst;
          goto <D.41313>;
          <D.41312>:
          D.41228 = cfg->cbb;
          D.41228 = cfg->cbb;
          D.41228->last_ins = inst;
          D.41229 = D.41228->last_ins;
          D.41228->code = D.41229;
          <D.41313>:
        }
        goto <D.41314>;
        <D.41299>:
        <D.41314>:
        <D.41297>:
        D.41219 = cfg->mempool;
        inst = mono_mempool_alloc (D.41219, 80);
        inst->data.op[1].const_val = 0;
        D.41315 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.41315;
        inst->prev = 0B;
        D.41316 = inst->prev;
        inst->next = D.41316;
        inst->opcode = 393;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.41317 = inst->sreg3;
        inst->sreg2 = D.41317;
        D.41318 = inst->sreg2;
        inst->sreg1 = D.41318;
        D.41224 = cfg->ip;
        inst->cil_code = D.41224;
        inst->dreg = _length_reg;
        D.41248 = *args;
        D.41249 = D.41248->dreg;
        inst->sreg1 = D.41249;
        inst->data.op[0].const_val = 16;
        inst->type = 1;
        D.41319 = (unsigned char) __ins_flags;
        inst->flags = D.41319;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        if (D.41229 != 0B) goto <D.41320>; else goto <D.41321>;
        <D.41320>:
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        D.41229->next = inst;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        inst->prev = D.41229;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        goto <D.41322>;
        <D.41321>:
        D.41228 = cfg->cbb;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        D.41229 = D.41228->last_ins;
        D.41228->code = D.41229;
        <D.41322>:
      }
      <D.41294>:
      {
        struct MonoInst * inst;

        D.41219 = cfg->mempool;
        inst = mono_mempool_alloc (D.41219, 80);
        inst->data.op[1].const_val = 0;
        D.41323 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.41323;
        inst->prev = 0B;
        D.41324 = inst->prev;
        inst->next = D.41324;
        inst->opcode = 322;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.41325 = inst->sreg3;
        inst->sreg2 = D.41325;
        D.41326 = inst->sreg2;
        inst->sreg1 = D.41326;
        D.41224 = cfg->ip;
        inst->cil_code = D.41224;
        inst->dreg = -1;
        inst->sreg1 = _length_reg;
        inst->sreg2 = index_reg;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        if (D.41229 != 0B) goto <D.41327>; else goto <D.41328>;
        <D.41327>:
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        D.41229->next = inst;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        inst->prev = D.41229;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        goto <D.41329>;
        <D.41328>:
        D.41228 = cfg->cbb;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        D.41229 = D.41228->last_ins;
        D.41228->code = D.41229;
        <D.41329>:
      }
      {
        struct MonoInst * inst;

        D.41219 = cfg->mempool;
        inst = mono_mempool_alloc (D.41219, 80);
        inst->data.op[1].const_val = 0;
        D.41330 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.41330;
        inst->prev = 0B;
        D.41331 = inst->prev;
        inst->next = D.41331;
        inst->opcode = 459;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.41332 = inst->sreg3;
        inst->sreg2 = D.41332;
        D.41333 = inst->sreg2;
        inst->sreg1 = D.41333;
        D.41224 = cfg->ip;
        inst->cil_code = D.41224;
        inst->data.op[1].p = "IndexOutOfRangeException";
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        if (D.41229 != 0B) goto <D.41334>; else goto <D.41335>;
        <D.41334>:
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        D.41229->next = inst;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        inst->prev = D.41229;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        goto <D.41336>;
        <D.41335>:
        D.41228 = cfg->cbb;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        D.41229 = D.41228->last_ins;
        D.41228->code = D.41229;
        <D.41336>:
      }
    }
    goto <D.41337>;
    <D.41262>:
    {
      int _length_reg;

      D.41338 = alloc_ireg (cfg);
      _length_reg = (int) D.41338;
      if (1 != 0) goto <D.41339>; else goto <D.41340>;
      <D.41339>:
      {
        struct MonoInst * inst;
        int __ins_flags;

        __ins_flags = 32;
        D.41341 = __ins_flags & 32;
        if (D.41341 != 0) goto <D.41342>; else goto <D.41343>;
        <D.41342>:
        D.41240 = BIT_FIELD_REF <*cfg, 64, 5632>;
        D.41241 = D.41240 & 144115188075855872;
        if (D.41241 != 0) goto <D.41344>; else goto <D.41345>;
        <D.41344>:
        {
          struct MonoInst * inst;

          D.41219 = cfg->mempool;
          inst = mono_mempool_alloc (D.41219, 80);
          inst->data.op[1].const_val = 0;
          D.41346 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.41346;
          inst->prev = 0B;
          D.41347 = inst->prev;
          inst->next = D.41347;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.41348 = inst->sreg3;
          inst->sreg2 = D.41348;
          D.41349 = inst->sreg2;
          inst->sreg1 = D.41349;
          D.41224 = cfg->ip;
          inst->cil_code = D.41224;
          inst->dreg = -1;
          D.41248 = *args;
          D.41249 = D.41248->dreg;
          inst->sreg1 = D.41249;
          inst->data.op[1].const_val = 0;
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          if (D.41229 != 0B) goto <D.41350>; else goto <D.41351>;
          <D.41350>:
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          D.41229->next = inst;
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          inst->prev = D.41229;
          D.41228 = cfg->cbb;
          D.41228->last_ins = inst;
          goto <D.41352>;
          <D.41351>:
          D.41228 = cfg->cbb;
          D.41228 = cfg->cbb;
          D.41228->last_ins = inst;
          D.41229 = D.41228->last_ins;
          D.41228->code = D.41229;
          <D.41352>:
        }
        {
          struct MonoInst * inst;

          D.41219 = cfg->mempool;
          inst = mono_mempool_alloc (D.41219, 80);
          inst->data.op[1].const_val = 0;
          D.41353 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.41353;
          inst->prev = 0B;
          D.41354 = inst->prev;
          inst->next = D.41354;
          inst->opcode = 451;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.41355 = inst->sreg3;
          inst->sreg2 = D.41355;
          D.41356 = inst->sreg2;
          inst->sreg1 = D.41356;
          D.41224 = cfg->ip;
          inst->cil_code = D.41224;
          inst->data.op[1].p = "NullReferenceException";
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          if (D.41229 != 0B) goto <D.41357>; else goto <D.41358>;
          <D.41357>:
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          D.41229->next = inst;
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          inst->prev = D.41229;
          D.41228 = cfg->cbb;
          D.41228->last_ins = inst;
          goto <D.41359>;
          <D.41358>:
          D.41228 = cfg->cbb;
          D.41228 = cfg->cbb;
          D.41228->last_ins = inst;
          D.41229 = D.41228->last_ins;
          D.41228->code = D.41229;
          <D.41359>:
        }
        goto <D.41360>;
        <D.41345>:
        <D.41360>:
        <D.41343>:
        D.41219 = cfg->mempool;
        inst = mono_mempool_alloc (D.41219, 80);
        inst->data.op[1].const_val = 0;
        D.41361 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.41361;
        inst->prev = 0B;
        D.41362 = inst->prev;
        inst->next = D.41362;
        inst->opcode = 393;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.41363 = inst->sreg3;
        inst->sreg2 = D.41363;
        D.41364 = inst->sreg2;
        inst->sreg1 = D.41364;
        D.41224 = cfg->ip;
        inst->cil_code = D.41224;
        inst->dreg = _length_reg;
        D.41248 = *args;
        D.41249 = D.41248->dreg;
        inst->sreg1 = D.41249;
        inst->data.op[0].const_val = 16;
        inst->type = 1;
        D.41365 = (unsigned char) __ins_flags;
        inst->flags = D.41365;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        if (D.41229 != 0B) goto <D.41366>; else goto <D.41367>;
        <D.41366>:
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        D.41229->next = inst;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        inst->prev = D.41229;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        goto <D.41368>;
        <D.41367>:
        D.41228 = cfg->cbb;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        D.41229 = D.41228->last_ins;
        D.41228->code = D.41229;
        <D.41368>:
      }
      goto <D.41369>;
      <D.41340>:
      {
        struct MonoInst * inst;
        int __ins_flags;

        __ins_flags = 64;
        D.41370 = __ins_flags & 32;
        if (D.41370 != 0) goto <D.41371>; else goto <D.41372>;
        <D.41371>:
        D.41240 = BIT_FIELD_REF <*cfg, 64, 5632>;
        D.41241 = D.41240 & 144115188075855872;
        if (D.41241 != 0) goto <D.41373>; else goto <D.41374>;
        <D.41373>:
        {
          struct MonoInst * inst;

          D.41219 = cfg->mempool;
          inst = mono_mempool_alloc (D.41219, 80);
          inst->data.op[1].const_val = 0;
          D.41375 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.41375;
          inst->prev = 0B;
          D.41376 = inst->prev;
          inst->next = D.41376;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.41377 = inst->sreg3;
          inst->sreg2 = D.41377;
          D.41378 = inst->sreg2;
          inst->sreg1 = D.41378;
          D.41224 = cfg->ip;
          inst->cil_code = D.41224;
          inst->dreg = -1;
          D.41248 = *args;
          D.41249 = D.41248->dreg;
          inst->sreg1 = D.41249;
          inst->data.op[1].const_val = 0;
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          if (D.41229 != 0B) goto <D.41379>; else goto <D.41380>;
          <D.41379>:
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          D.41229->next = inst;
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          inst->prev = D.41229;
          D.41228 = cfg->cbb;
          D.41228->last_ins = inst;
          goto <D.41381>;
          <D.41380>:
          D.41228 = cfg->cbb;
          D.41228 = cfg->cbb;
          D.41228->last_ins = inst;
          D.41229 = D.41228->last_ins;
          D.41228->code = D.41229;
          <D.41381>:
        }
        {
          struct MonoInst * inst;

          D.41219 = cfg->mempool;
          inst = mono_mempool_alloc (D.41219, 80);
          inst->data.op[1].const_val = 0;
          D.41382 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.41382;
          inst->prev = 0B;
          D.41383 = inst->prev;
          inst->next = D.41383;
          inst->opcode = 451;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.41384 = inst->sreg3;
          inst->sreg2 = D.41384;
          D.41385 = inst->sreg2;
          inst->sreg1 = D.41385;
          D.41224 = cfg->ip;
          inst->cil_code = D.41224;
          inst->data.op[1].p = "NullReferenceException";
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          if (D.41229 != 0B) goto <D.41386>; else goto <D.41387>;
          <D.41386>:
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          D.41229->next = inst;
          D.41228 = cfg->cbb;
          D.41229 = D.41228->last_ins;
          inst->prev = D.41229;
          D.41228 = cfg->cbb;
          D.41228->last_ins = inst;
          goto <D.41388>;
          <D.41387>:
          D.41228 = cfg->cbb;
          D.41228 = cfg->cbb;
          D.41228->last_ins = inst;
          D.41229 = D.41228->last_ins;
          D.41228->code = D.41229;
          <D.41388>:
        }
        goto <D.41389>;
        <D.41374>:
        <D.41389>:
        <D.41372>:
        D.41219 = cfg->mempool;
        inst = mono_mempool_alloc (D.41219, 80);
        inst->data.op[1].const_val = 0;
        D.41390 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.41390;
        inst->prev = 0B;
        D.41391 = inst->prev;
        inst->next = D.41391;
        inst->opcode = 393;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.41392 = inst->sreg3;
        inst->sreg2 = D.41392;
        D.41393 = inst->sreg2;
        inst->sreg1 = D.41393;
        D.41224 = cfg->ip;
        inst->cil_code = D.41224;
        inst->dreg = _length_reg;
        D.41248 = *args;
        D.41249 = D.41248->dreg;
        inst->sreg1 = D.41249;
        inst->data.op[0].const_val = 16;
        inst->type = 1;
        D.41394 = (unsigned char) __ins_flags;
        inst->flags = D.41394;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        if (D.41229 != 0B) goto <D.41395>; else goto <D.41396>;
        <D.41395>:
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        D.41229->next = inst;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        inst->prev = D.41229;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        goto <D.41397>;
        <D.41396>:
        D.41228 = cfg->cbb;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        D.41229 = D.41228->last_ins;
        D.41228->code = D.41229;
        <D.41397>:
      }
      <D.41369>:
      {
        struct MonoInst * inst;

        D.41219 = cfg->mempool;
        inst = mono_mempool_alloc (D.41219, 80);
        inst->data.op[1].const_val = 0;
        D.41398 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.41398;
        inst->prev = 0B;
        D.41399 = inst->prev;
        inst->next = D.41399;
        inst->opcode = 322;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.41400 = inst->sreg3;
        inst->sreg2 = D.41400;
        D.41401 = inst->sreg2;
        inst->sreg1 = D.41401;
        D.41224 = cfg->ip;
        inst->cil_code = D.41224;
        inst->dreg = -1;
        inst->sreg1 = _length_reg;
        inst->sreg2 = index_reg;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        if (D.41229 != 0B) goto <D.41402>; else goto <D.41403>;
        <D.41402>:
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        D.41229->next = inst;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        inst->prev = D.41229;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        goto <D.41404>;
        <D.41403>:
        D.41228 = cfg->cbb;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        D.41229 = D.41228->last_ins;
        D.41228->code = D.41229;
        <D.41404>:
      }
      {
        struct MonoInst * inst;

        D.41219 = cfg->mempool;
        inst = mono_mempool_alloc (D.41219, 80);
        inst->data.op[1].const_val = 0;
        D.41405 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.41405;
        inst->prev = 0B;
        D.41406 = inst->prev;
        inst->next = D.41406;
        inst->opcode = 459;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.41407 = inst->sreg3;
        inst->sreg2 = D.41407;
        D.41408 = inst->sreg2;
        inst->sreg1 = D.41408;
        D.41224 = cfg->ip;
        inst->cil_code = D.41224;
        inst->data.op[1].p = "IndexOutOfRangeException";
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        if (D.41229 != 0B) goto <D.41409>; else goto <D.41410>;
        <D.41409>:
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        D.41229->next = inst;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        inst->prev = D.41229;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        goto <D.41411>;
        <D.41410>:
        D.41228 = cfg->cbb;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        D.41229 = D.41228->last_ins;
        D.41228->code = D.41229;
        <D.41411>:
      }
    }
    <D.41337>:
    goto <D.41412>;
    <D.41239>:
    {
      struct MonoInst * ins;

      D.41219 = cfg->mempool;
      ins = mono_mempool_alloc (D.41219, 80);
      ins->data.op[1].const_val = 0;
      D.41413 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.41413;
      ins->prev = 0B;
      D.41414 = ins->prev;
      ins->next = D.41414;
      ins->opcode = 784;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.41415 = ins->sreg3;
      ins->sreg2 = D.41415;
      D.41416 = ins->sreg2;
      ins->sreg1 = D.41416;
      D.41224 = cfg->ip;
      ins->cil_code = D.41224;
      D.41248 = *args;
      D.41249 = D.41248->dreg;
      ins->sreg1 = D.41249;
      ins->sreg2 = index_reg;
      ins->data.op[1].const_val = 16;
      D.41417 = ins->flags;
      D.41418 = D.41417 | 32;
      ins->flags = D.41418;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41419>; else goto <D.41420>;
      <D.41419>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41229->next = ins;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      ins->prev = D.41229;
      D.41228 = cfg->cbb;
      D.41228->last_ins = ins;
      goto <D.41421>;
      <D.41420>:
      D.41228 = cfg->cbb;
      D.41228 = cfg->cbb;
      D.41228->last_ins = ins;
      D.41229 = D.41228->last_ins;
      D.41228->code = D.41229;
      <D.41421>:
      D.41422 = cfg->flags;
      D.41423 = D.41422 | 256;
      cfg->flags = D.41423;
      D.41228 = cfg->cbb;
      D.41228->has_array_access = 1;
    }
    <D.41412>:
    <D.41236>:
    {
      struct MonoInst * inst;

      D.41219 = cfg->mempool;
      inst = mono_mempool_alloc (D.41219, 80);
      inst->data.op[1].const_val = 0;
      D.41424 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.41424;
      inst->prev = 0B;
      D.41425 = inst->prev;
      inst->next = D.41425;
      inst->opcode = 439;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.41426 = inst->sreg3;
      inst->sreg2 = D.41426;
      D.41427 = inst->sreg2;
      inst->sreg1 = D.41427;
      D.41224 = cfg->ip;
      inst->cil_code = D.41224;
      inst->dreg = mult_reg;
      inst->sreg1 = index_reg;
      inst->data.op[1].const_val = 1;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41428>; else goto <D.41429>;
      <D.41428>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41229->next = inst;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      inst->prev = D.41229;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      goto <D.41430>;
      <D.41429>:
      D.41228 = cfg->cbb;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      D.41229 = D.41228->last_ins;
      D.41228->code = D.41229;
      <D.41430>:
    }
    {
      struct MonoInst * inst;

      D.41219 = cfg->mempool;
      inst = mono_mempool_alloc (D.41219, 80);
      inst->data.op[1].const_val = 0;
      D.41431 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.41431;
      inst->prev = 0B;
      D.41432 = inst->prev;
      inst->next = D.41432;
      inst->opcode = 479;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.41433 = inst->sreg3;
      inst->sreg2 = D.41433;
      D.41434 = inst->sreg2;
      inst->sreg1 = D.41434;
      D.41224 = cfg->ip;
      inst->cil_code = D.41224;
      inst->dreg = add_reg;
      inst->sreg1 = mult_reg;
      D.41248 = *args;
      D.41249 = D.41248->dreg;
      inst->sreg2 = D.41249;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41435>; else goto <D.41436>;
      <D.41435>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41229->next = inst;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      inst->prev = D.41229;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      goto <D.41437>;
      <D.41436>:
      D.41228 = cfg->cbb;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      D.41229 = D.41228->last_ins;
      D.41228->code = D.41229;
      <D.41437>:
    }
    D.41219 = cfg->mempool;
    ins = mono_mempool_alloc (D.41219, 80);
    ins->data.op[1].const_val = 0;
    D.41438 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.41438;
    ins->prev = 0B;
    D.41439 = ins->prev;
    ins->next = D.41439;
    ins->opcode = 392;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.41440 = ins->sreg3;
    ins->sreg2 = D.41440;
    D.41441 = ins->sreg2;
    ins->sreg1 = D.41441;
    D.41224 = cfg->ip;
    ins->cil_code = D.41224;
    ins->dreg = dreg;
    ins->sreg1 = add_reg;
    ins->data.op[0].const_val = 20;
    ins->type = 1;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 != 0B) goto <D.41442>; else goto <D.41443>;
    <D.41442>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41229->next = ins;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    ins->prev = D.41229;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    goto <D.41444>;
    <D.41443>:
    D.41228 = cfg->cbb;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    D.41229 = D.41228->last_ins;
    D.41228->code = D.41229;
    <D.41444>:
    type_from_op (ins, 0B, 0B);
    D.41445 = ins;
    return D.41445;
  }
  <D.41214>:
  D.41211 = cmethod->name;
  D.41446 = strcmp (D.41211, "get_Length");
  if (D.41446 == 0) goto <D.41447>; else goto <D.41448>;
  <D.41447>:
  {
    int dreg;

    D.41449 = alloc_ireg (cfg);
    dreg = (int) D.41449;
    D.41219 = cfg->mempool;
    ins = mono_mempool_alloc (D.41219, 80);
    ins->data.op[1].const_val = 0;
    D.41438 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.41438;
    ins->prev = 0B;
    D.41439 = ins->prev;
    ins->next = D.41439;
    ins->opcode = 781;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.41440 = ins->sreg3;
    ins->sreg2 = D.41440;
    D.41441 = ins->sreg2;
    ins->sreg1 = D.41441;
    D.41224 = cfg->ip;
    ins->cil_code = D.41224;
    ins->dreg = dreg;
    D.41248 = *args;
    D.41249 = D.41248->dreg;
    ins->sreg1 = D.41249;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 != 0B) goto <D.41450>; else goto <D.41451>;
    <D.41450>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41229->next = ins;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    ins->prev = D.41229;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    goto <D.41452>;
    <D.41451>:
    D.41228 = cfg->cbb;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    D.41229 = D.41228->last_ins;
    D.41228->code = D.41229;
    <D.41452>:
    ins->type = 1;
    D.41453 = ins->flags;
    D.41454 = D.41453 | 32;
    ins->flags = D.41454;
    D.41228 = cfg->cbb;
    D.41228->has_array_access = 1;
    D.41422 = cfg->flags;
    D.41423 = D.41422 | 256;
    cfg->flags = D.41423;
    D.41445 = ins;
    return D.41445;
  }
  <D.41448>:
  D.41211 = cmethod->name;
  D.41455 = strcmp (D.41211, "InternalSetChar");
  if (D.41455 == 0) goto <D.41456>; else goto <D.41457>;
  <D.41456>:
  {
    int mult_reg;
    int add_reg;

    D.41458 = alloc_preg (cfg);
    mult_reg = (int) D.41458;
    D.41459 = alloc_preg (cfg);
    add_reg = (int) D.41459;
    {
      struct MonoInst * inst;

      D.41219 = cfg->mempool;
      inst = mono_mempool_alloc (D.41219, 80);
      inst->data.op[1].const_val = 0;
      D.41460 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.41460;
      inst->prev = 0B;
      D.41461 = inst->prev;
      inst->next = D.41461;
      inst->opcode = 439;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.41462 = inst->sreg3;
      inst->sreg2 = D.41462;
      D.41463 = inst->sreg2;
      inst->sreg1 = D.41463;
      D.41224 = cfg->ip;
      inst->cil_code = D.41224;
      inst->dreg = mult_reg;
      D.41225 = args + 8;
      D.41226 = *D.41225;
      D.41227 = D.41226->dreg;
      inst->sreg1 = D.41227;
      inst->data.op[1].const_val = 1;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41464>; else goto <D.41465>;
      <D.41464>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41229->next = inst;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      inst->prev = D.41229;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      goto <D.41466>;
      <D.41465>:
      D.41228 = cfg->cbb;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      D.41229 = D.41228->last_ins;
      D.41228->code = D.41229;
      <D.41466>:
    }
    {
      struct MonoInst * inst;

      D.41219 = cfg->mempool;
      inst = mono_mempool_alloc (D.41219, 80);
      inst->data.op[1].const_val = 0;
      D.41467 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.41467;
      inst->prev = 0B;
      D.41468 = inst->prev;
      inst->next = D.41468;
      inst->opcode = 479;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.41469 = inst->sreg3;
      inst->sreg2 = D.41469;
      D.41470 = inst->sreg2;
      inst->sreg1 = D.41470;
      D.41224 = cfg->ip;
      inst->cil_code = D.41224;
      inst->dreg = add_reg;
      inst->sreg1 = mult_reg;
      D.41248 = *args;
      D.41249 = D.41248->dreg;
      inst->sreg2 = D.41249;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41471>; else goto <D.41472>;
      <D.41471>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41229->next = inst;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      inst->prev = D.41229;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      goto <D.41473>;
      <D.41472>:
      D.41228 = cfg->cbb;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      D.41229 = D.41228->last_ins;
      D.41228->code = D.41229;
      <D.41473>:
    }
    {
      struct MonoInst * inst;

      D.41219 = cfg->mempool;
      inst = mono_mempool_alloc (D.41219, 80);
      inst->data.op[1].const_val = 0;
      D.41474 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.41474;
      inst->prev = 0B;
      D.41475 = inst->prev;
      inst->next = D.41475;
      inst->opcode = 376;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.41476 = inst->sreg3;
      inst->sreg2 = D.41476;
      D.41477 = inst->sreg2;
      inst->sreg1 = D.41477;
      D.41224 = cfg->ip;
      inst->cil_code = D.41224;
      D.41478 = args + 16;
      D.41479 = *D.41478;
      D.41480 = D.41479->dreg;
      inst->sreg1 = D.41480;
      inst->dreg = add_reg;
      inst->data.op[0].const_val = 20;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41481>; else goto <D.41482>;
      <D.41481>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41229->next = inst;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      inst->prev = D.41229;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      goto <D.41483>;
      <D.41482>:
      D.41228 = cfg->cbb;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      D.41229 = D.41228->last_ins;
      D.41228->code = D.41229;
      <D.41483>:
    }
    D.41228 = cfg->cbb;
    D.41445 = D.41228->last_ins;
    return D.41445;
  }
  <D.41457>:
  D.41445 = 0B;
  return D.41445;
  <D.41210>:
  D.41207 = cmethod->klass;
  D.41484 = mono_defaults.object_class;
  if (D.41207 == D.41484) goto <D.41485>; else goto <D.41486>;
  <D.41485>:
  D.41211 = cmethod->name;
  D.41487 = strcmp (D.41211, "GetType");
  if (D.41487 == 0) goto <D.41488>; else goto <D.41489>;
  <D.41488>:
  {
    int dreg;
    int vt_reg;

    D.41490 = alloc_ireg_ref (cfg);
    dreg = (int) D.41490;
    D.41491 = alloc_preg (cfg);
    vt_reg = (int) D.41491;
    {
      struct MonoInst * inst;
      int __ins_flags;

      __ins_flags = 32;
      D.41492 = __ins_flags & 32;
      if (D.41492 != 0) goto <D.41493>; else goto <D.41494>;
      <D.41493>:
      D.41240 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.41241 = D.41240 & 144115188075855872;
      if (D.41241 != 0) goto <D.41495>; else goto <D.41496>;
      <D.41495>:
      {
        struct MonoInst * inst;

        D.41219 = cfg->mempool;
        inst = mono_mempool_alloc (D.41219, 80);
        inst->data.op[1].const_val = 0;
        D.41497 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.41497;
        inst->prev = 0B;
        D.41498 = inst->prev;
        inst->next = D.41498;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.41499 = inst->sreg3;
        inst->sreg2 = D.41499;
        D.41500 = inst->sreg2;
        inst->sreg1 = D.41500;
        D.41224 = cfg->ip;
        inst->cil_code = D.41224;
        inst->dreg = -1;
        D.41248 = *args;
        D.41249 = D.41248->dreg;
        inst->sreg1 = D.41249;
        inst->data.op[1].const_val = 0;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        if (D.41229 != 0B) goto <D.41501>; else goto <D.41502>;
        <D.41501>:
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        D.41229->next = inst;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        inst->prev = D.41229;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        goto <D.41503>;
        <D.41502>:
        D.41228 = cfg->cbb;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        D.41229 = D.41228->last_ins;
        D.41228->code = D.41229;
        <D.41503>:
      }
      {
        struct MonoInst * inst;

        D.41219 = cfg->mempool;
        inst = mono_mempool_alloc (D.41219, 80);
        inst->data.op[1].const_val = 0;
        D.41504 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.41504;
        inst->prev = 0B;
        D.41505 = inst->prev;
        inst->next = D.41505;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.41506 = inst->sreg3;
        inst->sreg2 = D.41506;
        D.41507 = inst->sreg2;
        inst->sreg1 = D.41507;
        D.41224 = cfg->ip;
        inst->cil_code = D.41224;
        inst->data.op[1].p = "NullReferenceException";
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        if (D.41229 != 0B) goto <D.41508>; else goto <D.41509>;
        <D.41508>:
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        D.41229->next = inst;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        inst->prev = D.41229;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        goto <D.41510>;
        <D.41509>:
        D.41228 = cfg->cbb;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        D.41229 = D.41228->last_ins;
        D.41228->code = D.41229;
        <D.41510>:
      }
      goto <D.41511>;
      <D.41496>:
      <D.41511>:
      <D.41494>:
      D.41219 = cfg->mempool;
      inst = mono_mempool_alloc (D.41219, 80);
      inst->data.op[1].const_val = 0;
      D.41512 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.41512;
      inst->prev = 0B;
      D.41513 = inst->prev;
      inst->next = D.41513;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.41514 = inst->sreg3;
      inst->sreg2 = D.41514;
      D.41515 = inst->sreg2;
      inst->sreg1 = D.41515;
      D.41224 = cfg->ip;
      inst->cil_code = D.41224;
      inst->dreg = vt_reg;
      D.41248 = *args;
      D.41249 = D.41248->dreg;
      inst->sreg1 = D.41249;
      inst->data.op[0].const_val = 0;
      inst->type = 1;
      D.41516 = (unsigned char) __ins_flags;
      inst->flags = D.41516;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41517>; else goto <D.41518>;
      <D.41517>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41229->next = inst;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      inst->prev = D.41229;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      goto <D.41519>;
      <D.41518>:
      D.41228 = cfg->cbb;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      D.41229 = D.41228->last_ins;
      D.41228->code = D.41229;
      <D.41519>:
    }
    D.41219 = cfg->mempool;
    ins = mono_mempool_alloc (D.41219, 80);
    ins->data.op[1].const_val = 0;
    D.41438 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.41438;
    ins->prev = 0B;
    D.41439 = ins->prev;
    ins->next = D.41439;
    ins->opcode = 388;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.41440 = ins->sreg3;
    ins->sreg2 = D.41440;
    D.41441 = ins->sreg2;
    ins->sreg1 = D.41441;
    D.41224 = cfg->ip;
    ins->cil_code = D.41224;
    ins->dreg = dreg;
    ins->sreg1 = vt_reg;
    ins->data.op[0].const_val = 24;
    ins->type = 1;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 != 0B) goto <D.41520>; else goto <D.41521>;
    <D.41520>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41229->next = ins;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    ins->prev = D.41229;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    goto <D.41522>;
    <D.41521>:
    D.41228 = cfg->cbb;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    D.41229 = D.41228->last_ins;
    D.41228->code = D.41229;
    <D.41522>:
    type_from_op (ins, 0B, 0B);
    D.41445 = ins;
    return D.41445;
  }
  <D.41489>:
  D.41211 = cmethod->name;
  D.41524 = strcmp (D.41211, "InternalGetHashCode");
  if (D.41524 == 0) goto <D.41525>; else goto <D.41523>;
  <D.41525>:
  D.41526 = mono_gc_is_moving ();
  if (D.41526 == 0) goto <D.41527>; else goto <D.41523>;
  <D.41527>:
  {
    int dreg;
    int t1;

    D.41528 = alloc_ireg (cfg);
    dreg = (int) D.41528;
    D.41529 = alloc_ireg (cfg);
    t1 = (int) D.41529;
    {
      struct MonoInst * inst;

      D.41219 = cfg->mempool;
      inst = mono_mempool_alloc (D.41219, 80);
      inst->data.op[1].const_val = 0;
      D.41530 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.41530;
      inst->prev = 0B;
      D.41531 = inst->prev;
      inst->next = D.41531;
      inst->opcode = 439;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.41532 = inst->sreg3;
      inst->sreg2 = D.41532;
      D.41533 = inst->sreg2;
      inst->sreg1 = D.41533;
      D.41224 = cfg->ip;
      inst->cil_code = D.41224;
      inst->dreg = t1;
      D.41248 = *args;
      D.41249 = D.41248->dreg;
      inst->sreg1 = D.41249;
      inst->data.op[1].const_val = 3;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41534>; else goto <D.41535>;
      <D.41534>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41229->next = inst;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      inst->prev = D.41229;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      goto <D.41536>;
      <D.41535>:
      D.41228 = cfg->cbb;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      D.41229 = D.41228->last_ins;
      D.41228->code = D.41229;
      <D.41536>:
    }
    D.41219 = cfg->mempool;
    ins = mono_mempool_alloc (D.41219, 80);
    ins->data.op[1].const_val = 0;
    D.41438 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.41438;
    ins->prev = 0B;
    D.41439 = ins->prev;
    ins->next = D.41439;
    ins->opcode = 431;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.41440 = ins->sreg3;
    ins->sreg2 = D.41440;
    D.41441 = ins->sreg2;
    ins->sreg1 = D.41441;
    D.41224 = cfg->ip;
    ins->cil_code = D.41224;
    ins->dreg = dreg;
    ins->sreg1 = t1;
    ins->data.op[1].const_val = 2654435761;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 != 0B) goto <D.41537>; else goto <D.41538>;
    <D.41537>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41229->next = ins;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    ins->prev = D.41229;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    goto <D.41539>;
    <D.41538>:
    D.41228 = cfg->cbb;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    D.41229 = D.41228->last_ins;
    D.41228->code = D.41229;
    <D.41539>:
    ins->type = 1;
    D.41445 = ins;
    return D.41445;
  }
  <D.41523>:
  D.41211 = cmethod->name;
  D.41540 = strcmp (D.41211, ".ctor");
  if (D.41540 == 0) goto <D.41541>; else goto <D.41542>;
  <D.41541>:
  D.41219 = cfg->mempool;
  ins = mono_mempool_alloc (D.41219, 80);
  ins->data.op[1].const_val = 0;
  D.41438 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.41438;
  ins->prev = 0B;
  D.41439 = ins->prev;
  ins->next = D.41439;
  ins->opcode = 316;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.41440 = ins->sreg3;
  ins->sreg2 = D.41440;
  D.41441 = ins->sreg2;
  ins->sreg1 = D.41441;
  D.41224 = cfg->ip;
  ins->cil_code = D.41224;
  D.41228 = cfg->cbb;
  D.41229 = D.41228->last_ins;
  if (D.41229 != 0B) goto <D.41543>; else goto <D.41544>;
  <D.41543>:
  D.41228 = cfg->cbb;
  D.41229 = D.41228->last_ins;
  D.41229->next = ins;
  D.41228 = cfg->cbb;
  D.41229 = D.41228->last_ins;
  ins->prev = D.41229;
  D.41228 = cfg->cbb;
  D.41228->last_ins = ins;
  goto <D.41545>;
  <D.41544>:
  D.41228 = cfg->cbb;
  D.41228 = cfg->cbb;
  D.41228->last_ins = ins;
  D.41229 = D.41228->last_ins;
  D.41228->code = D.41229;
  <D.41545>:
  D.41445 = ins;
  return D.41445;
  <D.41542>:
  D.41445 = 0B;
  return D.41445;
  <D.41486>:
  D.41207 = cmethod->klass;
  D.41546 = mono_defaults.array_class;
  if (D.41207 == D.41546) goto <D.41547>; else goto <D.41548>;
  <D.41547>:
  D.41549 = cfg->gsharedvt;
  if (D.41549 == 0) goto <D.41550>; else goto <D.41551>;
  <D.41550>:
  D.41211 = cmethod->name;
  D.41552 = D.41211 + 1;
  D.41553 = strcmp (D.41552, "etGenericValueImpl");
  if (D.41553 == 0) goto <D.41554>; else goto <D.41555>;
  <D.41554>:
  D.41211 = cmethod->name;
  D.41556 = *D.41211;
  D.41557 = D.41556 == 83;
  D.41558 = (int) D.41557;
  D.41445 = emit_array_generic_access (cfg, fsig, args, D.41558);
  return D.41445;
  <D.41555>:
  <D.41551>:
  D.41211 = cmethod->name;
  D.41561 = strcmp (D.41211, "GetLength");
  if (D.41561 == 0) goto <D.41559>; else goto <D.41562>;
  <D.41562>:
  D.41211 = cmethod->name;
  D.41563 = strcmp (D.41211, "GetLowerBound");
  if (D.41563 == 0) goto <D.41559>; else goto <D.41560>;
  <D.41559>:
  D.41225 = args + 8;
  D.41226 = *D.41225;
  D.41564 = D.41226->opcode;
  if (D.41564 == 362) goto <D.41565>; else goto <D.41566>;
  <D.41565>:
  D.41225 = args + 8;
  D.41226 = *D.41225;
  D.41567 = D.41226->data.op[0].const_val;
  if (D.41567 == 0) goto <D.41568>; else goto <D.41569>;
  <D.41568>:
  {
    int dreg;
    int bounds_reg;
    struct MonoBasicBlock * end_bb;
    struct MonoBasicBlock * szarray_bb;
    gboolean get_length;

    D.41570 = alloc_ireg (cfg);
    dreg = (int) D.41570;
    D.41571 = alloc_ireg_mp (cfg);
    bounds_reg = (int) D.41571;
    D.41211 = cmethod->name;
    D.41572 = strcmp (D.41211, "GetLength");
    D.41573 = D.41572 == 0;
    get_length = (gboolean) D.41573;
    D.41219 = cfg->mempool;
    end_bb = mono_mempool_alloc0 (D.41219, 296);
    D.41574 = cfg->num_bblocks;
    D.41575 = D.41574;
    D.41576 = D.41575 + 1;
    cfg->num_bblocks = D.41576;
    D.41577 = (int) D.41575;
    end_bb->block_num = D.41577;
    D.41219 = cfg->mempool;
    szarray_bb = mono_mempool_alloc0 (D.41219, 296);
    D.41574 = cfg->num_bblocks;
    D.41578 = D.41574;
    D.41579 = D.41578 + 1;
    cfg->num_bblocks = D.41579;
    D.41580 = (int) D.41578;
    szarray_bb->block_num = D.41580;
    {
      int __ins_flags;

      __ins_flags = 32;
      D.41581 = __ins_flags & 32;
      if (D.41581 != 0) goto <D.41582>; else goto <D.41583>;
      <D.41582>:
      D.41240 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.41241 = D.41240 & 144115188075855872;
      if (D.41241 != 0) goto <D.41584>; else goto <D.41585>;
      <D.41584>:
      {
        struct MonoInst * inst;

        D.41219 = cfg->mempool;
        inst = mono_mempool_alloc (D.41219, 80);
        inst->data.op[1].const_val = 0;
        D.41586 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.41586;
        inst->prev = 0B;
        D.41587 = inst->prev;
        inst->next = D.41587;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.41588 = inst->sreg3;
        inst->sreg2 = D.41588;
        D.41589 = inst->sreg2;
        inst->sreg1 = D.41589;
        D.41224 = cfg->ip;
        inst->cil_code = D.41224;
        inst->dreg = -1;
        D.41248 = *args;
        D.41249 = D.41248->dreg;
        inst->sreg1 = D.41249;
        inst->data.op[1].const_val = 0;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        if (D.41229 != 0B) goto <D.41590>; else goto <D.41591>;
        <D.41590>:
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        D.41229->next = inst;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        inst->prev = D.41229;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        goto <D.41592>;
        <D.41591>:
        D.41228 = cfg->cbb;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        D.41229 = D.41228->last_ins;
        D.41228->code = D.41229;
        <D.41592>:
      }
      {
        struct MonoInst * inst;

        D.41219 = cfg->mempool;
        inst = mono_mempool_alloc (D.41219, 80);
        inst->data.op[1].const_val = 0;
        D.41593 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.41593;
        inst->prev = 0B;
        D.41594 = inst->prev;
        inst->next = D.41594;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.41595 = inst->sreg3;
        inst->sreg2 = D.41595;
        D.41596 = inst->sreg2;
        inst->sreg1 = D.41596;
        D.41224 = cfg->ip;
        inst->cil_code = D.41224;
        inst->data.op[1].p = "NullReferenceException";
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        if (D.41229 != 0B) goto <D.41597>; else goto <D.41598>;
        <D.41597>:
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        D.41229->next = inst;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        inst->prev = D.41229;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        goto <D.41599>;
        <D.41598>:
        D.41228 = cfg->cbb;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        D.41229 = D.41228->last_ins;
        D.41228->code = D.41229;
        <D.41599>:
      }
      goto <D.41600>;
      <D.41585>:
      <D.41600>:
      <D.41583>:
      D.41219 = cfg->mempool;
      ins = mono_mempool_alloc (D.41219, 80);
      ins->data.op[1].const_val = 0;
      D.41438 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.41438;
      ins->prev = 0B;
      D.41439 = ins->prev;
      ins->next = D.41439;
      ins->opcode = 388;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.41440 = ins->sreg3;
      ins->sreg2 = D.41440;
      D.41441 = ins->sreg2;
      ins->sreg1 = D.41441;
      D.41224 = cfg->ip;
      ins->cil_code = D.41224;
      ins->dreg = bounds_reg;
      D.41248 = *args;
      D.41249 = D.41248->dreg;
      ins->sreg1 = D.41249;
      ins->data.op[0].const_val = 16;
      ins->type = 1;
      D.41601 = (unsigned char) __ins_flags;
      ins->flags = D.41601;
    }
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 != 0B) goto <D.41602>; else goto <D.41603>;
    <D.41602>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41229->next = ins;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    ins->prev = D.41229;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    goto <D.41604>;
    <D.41603>:
    D.41228 = cfg->cbb;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    D.41229 = D.41228->last_ins;
    D.41228->code = D.41229;
    <D.41604>:
    {
      struct MonoInst * inst;

      D.41219 = cfg->mempool;
      inst = mono_mempool_alloc (D.41219, 80);
      inst->data.op[1].const_val = 0;
      D.41605 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.41605;
      inst->prev = 0B;
      D.41606 = inst->prev;
      inst->next = D.41606;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.41607 = inst->sreg3;
      inst->sreg2 = D.41607;
      D.41608 = inst->sreg2;
      inst->sreg1 = D.41608;
      D.41224 = cfg->ip;
      inst->cil_code = D.41224;
      inst->dreg = -1;
      inst->sreg1 = bounds_reg;
      inst->data.op[1].const_val = 0;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41609>; else goto <D.41610>;
      <D.41609>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41229->next = inst;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      inst->prev = D.41229;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      goto <D.41611>;
      <D.41610>:
      D.41228 = cfg->cbb;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      D.41229 = D.41228->last_ins;
      D.41228->code = D.41229;
      <D.41611>:
    }
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.41219 = cfg->mempool;
      ins = mono_mempool_alloc (D.41219, 80);
      ins->data.op[1].const_val = 0;
      D.41612 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.41612;
      ins->prev = 0B;
      D.41613 = ins->prev;
      ins->next = D.41613;
      ins->opcode = 648;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.41614 = ins->sreg3;
      ins->sreg2 = D.41614;
      D.41615 = ins->sreg2;
      ins->sreg1 = D.41615;
      D.41224 = cfg->ip;
      ins->cil_code = D.41224;
      if (0 != 0) goto <D.41616>; else goto <D.41617>;
      <D.41616>:
      D.41219 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.41219, 296);
      D.41574 = cfg->num_bblocks;
      D.41618 = D.41574;
      D.41619 = D.41618 + 1;
      cfg->num_bblocks = D.41619;
      D.41620 = (int) D.41618;
      falsebb->block_num = D.41620;
      ins->data.op[0].target_block = szarray_bb;
      D.41228 = cfg->cbb;
      mono_link_bblock (cfg, D.41228, szarray_bb);
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41621>; else goto <D.41622>;
      <D.41621>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41229->next = ins;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      ins->prev = D.41229;
      D.41228 = cfg->cbb;
      D.41228->last_ins = ins;
      goto <D.41623>;
      <D.41622>:
      D.41228 = cfg->cbb;
      D.41228 = cfg->cbb;
      D.41228->last_ins = ins;
      D.41229 = D.41228->last_ins;
      D.41228->code = D.41229;
      <D.41623>:
      D.41624 = falsebb->cil_code;
      if (D.41624 != 0B) goto <D.41625>; else goto <D.41626>;
      <D.41625>:
      D.41627 = cfg->cil_offset_to_bb;
      D.41624 = falsebb->cil_code;
      D.41628 = (long int) D.41624;
      D.41629 = cfg->cil_start;
      D.41630 = (long int) D.41629;
      D.41631 = D.41628 - D.41630;
      D.41632 = (long unsigned int) D.41631;
      D.41633 = D.41632 * 8;
      D.41634 = D.41627 + D.41633;
      *D.41634 = falsebb;
      <D.41626>:
      D.41635 = cfg->real_offset;
      falsebb->real_offset = D.41635;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41639>; else goto <D.41636>;
      <D.41639>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41641 = D.41640 + 64985;
      if (D.41641 <= 9) goto <D.41637>; else goto <D.41642>;
      <D.41642>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41643 = D.41640 + 64878;
      if (D.41643 <= 9) goto <D.41637>; else goto <D.41644>;
      <D.41644>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41645 = D.41640 + 64888;
      if (D.41645 <= 9) goto <D.41637>; else goto <D.41636>;
      <D.41637>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41646 = D.41229->data.op[1].many_blocks;
      D.41647 = D.41646 + 8;
      D.41648 = *D.41647;
      if (D.41648 == 0B) goto <D.41649>; else goto <D.41636>;
      <D.41649>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41646 = D.41229->data.op[1].many_blocks;
      D.41647 = D.41646 + 8;
      *D.41647 = falsebb;
      D.41228 = cfg->cbb;
      mono_link_bblock (cfg, D.41228, falsebb);
      goto <D.41638>;
      <D.41636>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 == 0B) goto <D.41650>; else goto <D.41652>;
      <D.41652>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      if (D.41640 != 442) goto <D.41653>; else goto <D.41651>;
      <D.41653>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      if (D.41640 != 759) goto <D.41654>; else goto <D.41651>;
      <D.41654>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41641 = D.41640 + 64985;
      if (D.41641 > 9) goto <D.41655>; else goto <D.41651>;
      <D.41655>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41643 = D.41640 + 64878;
      if (D.41643 > 9) goto <D.41656>; else goto <D.41651>;
      <D.41656>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41645 = D.41640 + 64888;
      if (D.41645 > 9) goto <D.41650>; else goto <D.41651>;
      <D.41650>:
      D.41228 = cfg->cbb;
      mono_link_bblock (cfg, D.41228, falsebb);
      <D.41651>:
      <D.41638>:
      D.41228 = cfg->cbb;
      D.41228->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.41657>;
      <D.41617>:
      D.41219 = cfg->mempool;
      D.41658 = mono_mempool_alloc (D.41219, 16);
      ins->data.op[1].many_blocks = D.41658;
      D.41659 = ins->data.op[1].many_blocks;
      *D.41659 = szarray_bb;
      D.41659 = ins->data.op[1].many_blocks;
      D.41660 = D.41659 + 8;
      *D.41660 = 0B;
      D.41228 = cfg->cbb;
      mono_link_bblock (cfg, D.41228, szarray_bb);
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41661>; else goto <D.41662>;
      <D.41661>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41229->next = ins;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      ins->prev = D.41229;
      D.41228 = cfg->cbb;
      D.41228->last_ins = ins;
      goto <D.41663>;
      <D.41662>:
      D.41228 = cfg->cbb;
      D.41228 = cfg->cbb;
      D.41228->last_ins = ins;
      D.41229 = D.41228->last_ins;
      D.41228->code = D.41229;
      <D.41663>:
      D.41664 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.41665 = D.41664 & 268435456;
      if (D.41665 == 0) goto <D.41666>; else goto <D.41667>;
      <D.41666>:
      D.41219 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.41219, 296);
      D.41574 = cfg->num_bblocks;
      D.41668 = D.41574;
      D.41669 = D.41668 + 1;
      cfg->num_bblocks = D.41669;
      D.41670 = (int) D.41668;
      falsebb->block_num = D.41670;
      D.41659 = ins->data.op[1].many_blocks;
      D.41660 = D.41659 + 8;
      *D.41660 = falsebb;
      D.41228 = cfg->cbb;
      mono_link_bblock (cfg, D.41228, falsebb);
      D.41624 = falsebb->cil_code;
      if (D.41624 != 0B) goto <D.41671>; else goto <D.41672>;
      <D.41671>:
      D.41627 = cfg->cil_offset_to_bb;
      D.41624 = falsebb->cil_code;
      D.41628 = (long int) D.41624;
      D.41629 = cfg->cil_start;
      D.41630 = (long int) D.41629;
      D.41631 = D.41628 - D.41630;
      D.41632 = (long unsigned int) D.41631;
      D.41633 = D.41632 * 8;
      D.41634 = D.41627 + D.41633;
      *D.41634 = falsebb;
      <D.41672>:
      D.41635 = cfg->real_offset;
      falsebb->real_offset = D.41635;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41676>; else goto <D.41673>;
      <D.41676>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41641 = D.41640 + 64985;
      if (D.41641 <= 9) goto <D.41674>; else goto <D.41677>;
      <D.41677>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41643 = D.41640 + 64878;
      if (D.41643 <= 9) goto <D.41674>; else goto <D.41678>;
      <D.41678>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41645 = D.41640 + 64888;
      if (D.41645 <= 9) goto <D.41674>; else goto <D.41673>;
      <D.41674>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41646 = D.41229->data.op[1].many_blocks;
      D.41647 = D.41646 + 8;
      D.41648 = *D.41647;
      if (D.41648 == 0B) goto <D.41679>; else goto <D.41673>;
      <D.41679>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41646 = D.41229->data.op[1].many_blocks;
      D.41647 = D.41646 + 8;
      *D.41647 = falsebb;
      D.41228 = cfg->cbb;
      mono_link_bblock (cfg, D.41228, falsebb);
      goto <D.41675>;
      <D.41673>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 == 0B) goto <D.41680>; else goto <D.41682>;
      <D.41682>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      if (D.41640 != 442) goto <D.41683>; else goto <D.41681>;
      <D.41683>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      if (D.41640 != 759) goto <D.41684>; else goto <D.41681>;
      <D.41684>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41641 = D.41640 + 64985;
      if (D.41641 > 9) goto <D.41685>; else goto <D.41681>;
      <D.41685>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41643 = D.41640 + 64878;
      if (D.41643 > 9) goto <D.41686>; else goto <D.41681>;
      <D.41686>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41645 = D.41640 + 64888;
      if (D.41645 > 9) goto <D.41680>; else goto <D.41681>;
      <D.41680>:
      D.41228 = cfg->cbb;
      mono_link_bblock (cfg, D.41228, falsebb);
      <D.41681>:
      <D.41675>:
      D.41228 = cfg->cbb;
      D.41228->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.41687>;
      <D.41667>:
      D.41228 = cfg->cbb;
      D.41228->extended = 1;
      <D.41687>:
      <D.41657>:
    }
    if (get_length != 0) goto <D.41688>; else goto <D.41689>;
    <D.41688>:
    D.41219 = cfg->mempool;
    ins = mono_mempool_alloc (D.41219, 80);
    ins->data.op[1].const_val = 0;
    D.41438 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.41438;
    ins->prev = 0B;
    D.41439 = ins->prev;
    ins->next = D.41439;
    ins->opcode = 393;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.41440 = ins->sreg3;
    ins->sreg2 = D.41440;
    D.41441 = ins->sreg2;
    ins->sreg1 = D.41441;
    D.41224 = cfg->ip;
    ins->cil_code = D.41224;
    ins->dreg = dreg;
    ins->sreg1 = bounds_reg;
    ins->data.op[0].const_val = 0;
    ins->type = 1;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 != 0B) goto <D.41690>; else goto <D.41691>;
    <D.41690>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41229->next = ins;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    ins->prev = D.41229;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    goto <D.41692>;
    <D.41691>:
    D.41228 = cfg->cbb;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    D.41229 = D.41228->last_ins;
    D.41228->code = D.41229;
    <D.41692>:
    goto <D.41693>;
    <D.41689>:
    D.41219 = cfg->mempool;
    ins = mono_mempool_alloc (D.41219, 80);
    ins->data.op[1].const_val = 0;
    D.41438 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.41438;
    ins->prev = 0B;
    D.41439 = ins->prev;
    ins->next = D.41439;
    ins->opcode = 393;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.41440 = ins->sreg3;
    ins->sreg2 = D.41440;
    D.41441 = ins->sreg2;
    ins->sreg1 = D.41441;
    D.41224 = cfg->ip;
    ins->cil_code = D.41224;
    ins->dreg = dreg;
    ins->sreg1 = bounds_reg;
    ins->data.op[0].const_val = 4;
    ins->type = 1;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 != 0B) goto <D.41694>; else goto <D.41695>;
    <D.41694>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41229->next = ins;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    ins->prev = D.41229;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    goto <D.41696>;
    <D.41695>:
    D.41228 = cfg->cbb;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    D.41229 = D.41228->last_ins;
    D.41228->code = D.41229;
    <D.41696>:
    <D.41693>:
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.41219 = cfg->mempool;
      ins = mono_mempool_alloc (D.41219, 80);
      ins->data.op[1].const_val = 0;
      D.41697 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.41697;
      ins->prev = 0B;
      D.41698 = ins->prev;
      ins->next = D.41698;
      ins->opcode = 442;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.41699 = ins->sreg3;
      ins->sreg2 = D.41699;
      D.41700 = ins->sreg2;
      ins->sreg1 = D.41700;
      D.41224 = cfg->ip;
      ins->cil_code = D.41224;
      if (1 != 0) goto <D.41701>; else goto <D.41702>;
      <D.41701>:
      D.41219 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.41219, 296);
      D.41574 = cfg->num_bblocks;
      D.41703 = D.41574;
      D.41704 = D.41703 + 1;
      cfg->num_bblocks = D.41704;
      D.41705 = (int) D.41703;
      falsebb->block_num = D.41705;
      ins->data.op[0].target_block = end_bb;
      D.41228 = cfg->cbb;
      mono_link_bblock (cfg, D.41228, end_bb);
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41706>; else goto <D.41707>;
      <D.41706>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41229->next = ins;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      ins->prev = D.41229;
      D.41228 = cfg->cbb;
      D.41228->last_ins = ins;
      goto <D.41708>;
      <D.41707>:
      D.41228 = cfg->cbb;
      D.41228 = cfg->cbb;
      D.41228->last_ins = ins;
      D.41229 = D.41228->last_ins;
      D.41228->code = D.41229;
      <D.41708>:
      D.41709 = falsebb->cil_code;
      if (D.41709 != 0B) goto <D.41710>; else goto <D.41711>;
      <D.41710>:
      D.41627 = cfg->cil_offset_to_bb;
      D.41709 = falsebb->cil_code;
      D.41712 = (long int) D.41709;
      D.41629 = cfg->cil_start;
      D.41630 = (long int) D.41629;
      D.41713 = D.41712 - D.41630;
      D.41714 = (long unsigned int) D.41713;
      D.41715 = D.41714 * 8;
      D.41716 = D.41627 + D.41715;
      *D.41716 = falsebb;
      <D.41711>:
      D.41635 = cfg->real_offset;
      falsebb->real_offset = D.41635;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41720>; else goto <D.41717>;
      <D.41720>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41641 = D.41640 + 64985;
      if (D.41641 <= 9) goto <D.41718>; else goto <D.41721>;
      <D.41721>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41643 = D.41640 + 64878;
      if (D.41643 <= 9) goto <D.41718>; else goto <D.41722>;
      <D.41722>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41645 = D.41640 + 64888;
      if (D.41645 <= 9) goto <D.41718>; else goto <D.41717>;
      <D.41718>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41646 = D.41229->data.op[1].many_blocks;
      D.41647 = D.41646 + 8;
      D.41648 = *D.41647;
      if (D.41648 == 0B) goto <D.41723>; else goto <D.41717>;
      <D.41723>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41646 = D.41229->data.op[1].many_blocks;
      D.41647 = D.41646 + 8;
      *D.41647 = falsebb;
      D.41228 = cfg->cbb;
      mono_link_bblock (cfg, D.41228, falsebb);
      goto <D.41719>;
      <D.41717>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 == 0B) goto <D.41724>; else goto <D.41726>;
      <D.41726>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      if (D.41640 != 442) goto <D.41727>; else goto <D.41725>;
      <D.41727>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      if (D.41640 != 759) goto <D.41728>; else goto <D.41725>;
      <D.41728>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41641 = D.41640 + 64985;
      if (D.41641 > 9) goto <D.41729>; else goto <D.41725>;
      <D.41729>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41643 = D.41640 + 64878;
      if (D.41643 > 9) goto <D.41730>; else goto <D.41725>;
      <D.41730>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41645 = D.41640 + 64888;
      if (D.41645 > 9) goto <D.41724>; else goto <D.41725>;
      <D.41724>:
      D.41228 = cfg->cbb;
      mono_link_bblock (cfg, D.41228, falsebb);
      <D.41725>:
      <D.41719>:
      D.41228 = cfg->cbb;
      D.41228->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.41731>;
      <D.41702>:
      D.41219 = cfg->mempool;
      D.41732 = mono_mempool_alloc (D.41219, 16);
      ins->data.op[1].many_blocks = D.41732;
      D.41733 = ins->data.op[1].many_blocks;
      *D.41733 = end_bb;
      D.41733 = ins->data.op[1].many_blocks;
      D.41734 = D.41733 + 8;
      *D.41734 = 0B;
      D.41228 = cfg->cbb;
      mono_link_bblock (cfg, D.41228, end_bb);
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41735>; else goto <D.41736>;
      <D.41735>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41229->next = ins;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      ins->prev = D.41229;
      D.41228 = cfg->cbb;
      D.41228->last_ins = ins;
      goto <D.41737>;
      <D.41736>:
      D.41228 = cfg->cbb;
      D.41228 = cfg->cbb;
      D.41228->last_ins = ins;
      D.41229 = D.41228->last_ins;
      D.41228->code = D.41229;
      <D.41737>:
      D.41664 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.41665 = D.41664 & 268435456;
      if (D.41665 == 0) goto <D.41738>; else goto <D.41739>;
      <D.41738>:
      D.41219 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.41219, 296);
      D.41574 = cfg->num_bblocks;
      D.41740 = D.41574;
      D.41741 = D.41740 + 1;
      cfg->num_bblocks = D.41741;
      D.41742 = (int) D.41740;
      falsebb->block_num = D.41742;
      D.41733 = ins->data.op[1].many_blocks;
      D.41734 = D.41733 + 8;
      *D.41734 = falsebb;
      D.41228 = cfg->cbb;
      mono_link_bblock (cfg, D.41228, falsebb);
      D.41709 = falsebb->cil_code;
      if (D.41709 != 0B) goto <D.41743>; else goto <D.41744>;
      <D.41743>:
      D.41627 = cfg->cil_offset_to_bb;
      D.41709 = falsebb->cil_code;
      D.41712 = (long int) D.41709;
      D.41629 = cfg->cil_start;
      D.41630 = (long int) D.41629;
      D.41713 = D.41712 - D.41630;
      D.41714 = (long unsigned int) D.41713;
      D.41715 = D.41714 * 8;
      D.41716 = D.41627 + D.41715;
      *D.41716 = falsebb;
      <D.41744>:
      D.41635 = cfg->real_offset;
      falsebb->real_offset = D.41635;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41748>; else goto <D.41745>;
      <D.41748>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41641 = D.41640 + 64985;
      if (D.41641 <= 9) goto <D.41746>; else goto <D.41749>;
      <D.41749>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41643 = D.41640 + 64878;
      if (D.41643 <= 9) goto <D.41746>; else goto <D.41750>;
      <D.41750>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41645 = D.41640 + 64888;
      if (D.41645 <= 9) goto <D.41746>; else goto <D.41745>;
      <D.41746>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41646 = D.41229->data.op[1].many_blocks;
      D.41647 = D.41646 + 8;
      D.41648 = *D.41647;
      if (D.41648 == 0B) goto <D.41751>; else goto <D.41745>;
      <D.41751>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41646 = D.41229->data.op[1].many_blocks;
      D.41647 = D.41646 + 8;
      *D.41647 = falsebb;
      D.41228 = cfg->cbb;
      mono_link_bblock (cfg, D.41228, falsebb);
      goto <D.41747>;
      <D.41745>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 == 0B) goto <D.41752>; else goto <D.41754>;
      <D.41754>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      if (D.41640 != 442) goto <D.41755>; else goto <D.41753>;
      <D.41755>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      if (D.41640 != 759) goto <D.41756>; else goto <D.41753>;
      <D.41756>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41641 = D.41640 + 64985;
      if (D.41641 > 9) goto <D.41757>; else goto <D.41753>;
      <D.41757>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41643 = D.41640 + 64878;
      if (D.41643 > 9) goto <D.41758>; else goto <D.41753>;
      <D.41758>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41640 = D.41229->opcode;
      D.41645 = D.41640 + 64888;
      if (D.41645 > 9) goto <D.41752>; else goto <D.41753>;
      <D.41752>:
      D.41228 = cfg->cbb;
      mono_link_bblock (cfg, D.41228, falsebb);
      <D.41753>:
      <D.41747>:
      D.41228 = cfg->cbb;
      D.41228->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.41759>;
      <D.41739>:
      D.41228 = cfg->cbb;
      D.41228->extended = 1;
      <D.41759>:
      <D.41731>:
    }
    D.41760 = szarray_bb->cil_code;
    if (D.41760 != 0B) goto <D.41761>; else goto <D.41762>;
    <D.41761>:
    D.41627 = cfg->cil_offset_to_bb;
    D.41760 = szarray_bb->cil_code;
    D.41763 = (long int) D.41760;
    D.41629 = cfg->cil_start;
    D.41630 = (long int) D.41629;
    D.41764 = D.41763 - D.41630;
    D.41765 = (long unsigned int) D.41764;
    D.41766 = D.41765 * 8;
    D.41767 = D.41627 + D.41766;
    *D.41767 = szarray_bb;
    <D.41762>:
    D.41635 = cfg->real_offset;
    szarray_bb->real_offset = D.41635;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 != 0B) goto <D.41771>; else goto <D.41768>;
    <D.41771>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41640 = D.41229->opcode;
    D.41641 = D.41640 + 64985;
    if (D.41641 <= 9) goto <D.41769>; else goto <D.41772>;
    <D.41772>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41640 = D.41229->opcode;
    D.41643 = D.41640 + 64878;
    if (D.41643 <= 9) goto <D.41769>; else goto <D.41773>;
    <D.41773>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41640 = D.41229->opcode;
    D.41645 = D.41640 + 64888;
    if (D.41645 <= 9) goto <D.41769>; else goto <D.41768>;
    <D.41769>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41646 = D.41229->data.op[1].many_blocks;
    D.41647 = D.41646 + 8;
    D.41648 = *D.41647;
    if (D.41648 == 0B) goto <D.41774>; else goto <D.41768>;
    <D.41774>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41646 = D.41229->data.op[1].many_blocks;
    D.41647 = D.41646 + 8;
    *D.41647 = szarray_bb;
    D.41228 = cfg->cbb;
    mono_link_bblock (cfg, D.41228, szarray_bb);
    goto <D.41770>;
    <D.41768>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 == 0B) goto <D.41775>; else goto <D.41777>;
    <D.41777>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41640 = D.41229->opcode;
    if (D.41640 != 442) goto <D.41778>; else goto <D.41776>;
    <D.41778>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41640 = D.41229->opcode;
    if (D.41640 != 759) goto <D.41779>; else goto <D.41776>;
    <D.41779>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41640 = D.41229->opcode;
    D.41641 = D.41640 + 64985;
    if (D.41641 > 9) goto <D.41780>; else goto <D.41776>;
    <D.41780>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41640 = D.41229->opcode;
    D.41643 = D.41640 + 64878;
    if (D.41643 > 9) goto <D.41781>; else goto <D.41776>;
    <D.41781>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41640 = D.41229->opcode;
    D.41645 = D.41640 + 64888;
    if (D.41645 > 9) goto <D.41775>; else goto <D.41776>;
    <D.41775>:
    D.41228 = cfg->cbb;
    mono_link_bblock (cfg, D.41228, szarray_bb);
    <D.41776>:
    <D.41770>:
    D.41228 = cfg->cbb;
    D.41228->next_bb = szarray_bb;
    cfg->cbb = szarray_bb;
    if (get_length != 0) goto <D.41782>; else goto <D.41783>;
    <D.41782>:
    D.41219 = cfg->mempool;
    ins = mono_mempool_alloc (D.41219, 80);
    ins->data.op[1].const_val = 0;
    D.41438 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.41438;
    ins->prev = 0B;
    D.41439 = ins->prev;
    ins->next = D.41439;
    ins->opcode = 393;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.41440 = ins->sreg3;
    ins->sreg2 = D.41440;
    D.41441 = ins->sreg2;
    ins->sreg1 = D.41441;
    D.41224 = cfg->ip;
    ins->cil_code = D.41224;
    ins->dreg = dreg;
    D.41248 = *args;
    D.41249 = D.41248->dreg;
    ins->sreg1 = D.41249;
    ins->data.op[0].const_val = 24;
    ins->type = 1;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 != 0B) goto <D.41784>; else goto <D.41785>;
    <D.41784>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41229->next = ins;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    ins->prev = D.41229;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    goto <D.41786>;
    <D.41785>:
    D.41228 = cfg->cbb;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    D.41229 = D.41228->last_ins;
    D.41228->code = D.41229;
    <D.41786>:
    goto <D.41787>;
    <D.41783>:
    {
      struct MonoInst * inst;

      D.41219 = cfg->mempool;
      inst = mono_mempool_alloc (D.41219, 80);
      inst->data.op[1].const_val = 0;
      D.41788 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.41788;
      inst->prev = 0B;
      D.41789 = inst->prev;
      inst->next = D.41789;
      inst->opcode = 362;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.41790 = inst->sreg3;
      inst->sreg2 = D.41790;
      D.41791 = inst->sreg2;
      inst->sreg1 = D.41791;
      D.41224 = cfg->ip;
      inst->cil_code = D.41224;
      inst->dreg = dreg;
      inst->data.op[0].const_val = 0;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41792>; else goto <D.41793>;
      <D.41792>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41229->next = inst;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      inst->prev = D.41229;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      goto <D.41794>;
      <D.41793>:
      D.41228 = cfg->cbb;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      D.41229 = D.41228->last_ins;
      D.41228->code = D.41229;
      <D.41794>:
    }
    <D.41787>:
    D.41795 = end_bb->cil_code;
    if (D.41795 != 0B) goto <D.41796>; else goto <D.41797>;
    <D.41796>:
    D.41627 = cfg->cil_offset_to_bb;
    D.41795 = end_bb->cil_code;
    D.41798 = (long int) D.41795;
    D.41629 = cfg->cil_start;
    D.41630 = (long int) D.41629;
    D.41799 = D.41798 - D.41630;
    D.41800 = (long unsigned int) D.41799;
    D.41801 = D.41800 * 8;
    D.41802 = D.41627 + D.41801;
    *D.41802 = end_bb;
    <D.41797>:
    D.41635 = cfg->real_offset;
    end_bb->real_offset = D.41635;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 != 0B) goto <D.41806>; else goto <D.41803>;
    <D.41806>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41640 = D.41229->opcode;
    D.41641 = D.41640 + 64985;
    if (D.41641 <= 9) goto <D.41804>; else goto <D.41807>;
    <D.41807>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41640 = D.41229->opcode;
    D.41643 = D.41640 + 64878;
    if (D.41643 <= 9) goto <D.41804>; else goto <D.41808>;
    <D.41808>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41640 = D.41229->opcode;
    D.41645 = D.41640 + 64888;
    if (D.41645 <= 9) goto <D.41804>; else goto <D.41803>;
    <D.41804>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41646 = D.41229->data.op[1].many_blocks;
    D.41647 = D.41646 + 8;
    D.41648 = *D.41647;
    if (D.41648 == 0B) goto <D.41809>; else goto <D.41803>;
    <D.41809>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41646 = D.41229->data.op[1].many_blocks;
    D.41647 = D.41646 + 8;
    *D.41647 = end_bb;
    D.41228 = cfg->cbb;
    mono_link_bblock (cfg, D.41228, end_bb);
    goto <D.41805>;
    <D.41803>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 == 0B) goto <D.41810>; else goto <D.41812>;
    <D.41812>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41640 = D.41229->opcode;
    if (D.41640 != 442) goto <D.41813>; else goto <D.41811>;
    <D.41813>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41640 = D.41229->opcode;
    if (D.41640 != 759) goto <D.41814>; else goto <D.41811>;
    <D.41814>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41640 = D.41229->opcode;
    D.41641 = D.41640 + 64985;
    if (D.41641 > 9) goto <D.41815>; else goto <D.41811>;
    <D.41815>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41640 = D.41229->opcode;
    D.41643 = D.41640 + 64878;
    if (D.41643 > 9) goto <D.41816>; else goto <D.41811>;
    <D.41816>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41640 = D.41229->opcode;
    D.41645 = D.41640 + 64888;
    if (D.41645 > 9) goto <D.41810>; else goto <D.41811>;
    <D.41810>:
    D.41228 = cfg->cbb;
    mono_link_bblock (cfg, D.41228, end_bb);
    <D.41811>:
    <D.41805>:
    D.41228 = cfg->cbb;
    D.41228->next_bb = end_bb;
    cfg->cbb = end_bb;
    D.41219 = cfg->mempool;
    ins = mono_mempool_alloc (D.41219, 80);
    ins->data.op[1].const_val = 0;
    D.41438 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.41438;
    ins->prev = 0B;
    D.41439 = ins->prev;
    ins->next = D.41439;
    ins->opcode = 424;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.41440 = ins->sreg3;
    ins->sreg2 = D.41440;
    D.41441 = ins->sreg2;
    ins->sreg1 = D.41441;
    D.41224 = cfg->ip;
    ins->cil_code = D.41224;
    ins->dreg = dreg;
    ins->sreg1 = dreg;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 != 0B) goto <D.41817>; else goto <D.41818>;
    <D.41817>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41229->next = ins;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    ins->prev = D.41229;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    goto <D.41819>;
    <D.41818>:
    D.41228 = cfg->cbb;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    D.41229 = D.41228->last_ins;
    D.41228->code = D.41229;
    <D.41819>:
    ins->type = 1;
    D.41445 = ins;
    return D.41445;
  }
  <D.41569>:
  <D.41566>:
  <D.41560>:
  D.41211 = cmethod->name;
  D.41556 = *D.41211;
  if (D.41556 != 103) goto <D.41820>; else goto <D.41821>;
  <D.41820>:
  D.41445 = 0B;
  return D.41445;
  <D.41821>:
  D.41211 = cmethod->name;
  D.41822 = strcmp (D.41211, "get_Rank");
  if (D.41822 == 0) goto <D.41823>; else goto <D.41824>;
  <D.41823>:
  {
    int dreg;
    int vtable_reg;

    D.41825 = alloc_ireg (cfg);
    dreg = (int) D.41825;
    D.41826 = alloc_preg (cfg);
    vtable_reg = (int) D.41826;
    {
      struct MonoInst * inst;
      int __ins_flags;

      __ins_flags = 32;
      D.41827 = __ins_flags & 32;
      if (D.41827 != 0) goto <D.41828>; else goto <D.41829>;
      <D.41828>:
      D.41240 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.41241 = D.41240 & 144115188075855872;
      if (D.41241 != 0) goto <D.41830>; else goto <D.41831>;
      <D.41830>:
      {
        struct MonoInst * inst;

        D.41219 = cfg->mempool;
        inst = mono_mempool_alloc (D.41219, 80);
        inst->data.op[1].const_val = 0;
        D.41832 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.41832;
        inst->prev = 0B;
        D.41833 = inst->prev;
        inst->next = D.41833;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.41834 = inst->sreg3;
        inst->sreg2 = D.41834;
        D.41835 = inst->sreg2;
        inst->sreg1 = D.41835;
        D.41224 = cfg->ip;
        inst->cil_code = D.41224;
        inst->dreg = -1;
        D.41248 = *args;
        D.41249 = D.41248->dreg;
        inst->sreg1 = D.41249;
        inst->data.op[1].const_val = 0;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        if (D.41229 != 0B) goto <D.41836>; else goto <D.41837>;
        <D.41836>:
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        D.41229->next = inst;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        inst->prev = D.41229;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        goto <D.41838>;
        <D.41837>:
        D.41228 = cfg->cbb;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        D.41229 = D.41228->last_ins;
        D.41228->code = D.41229;
        <D.41838>:
      }
      {
        struct MonoInst * inst;

        D.41219 = cfg->mempool;
        inst = mono_mempool_alloc (D.41219, 80);
        inst->data.op[1].const_val = 0;
        D.41839 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.41839;
        inst->prev = 0B;
        D.41840 = inst->prev;
        inst->next = D.41840;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.41841 = inst->sreg3;
        inst->sreg2 = D.41841;
        D.41842 = inst->sreg2;
        inst->sreg1 = D.41842;
        D.41224 = cfg->ip;
        inst->cil_code = D.41224;
        inst->data.op[1].p = "NullReferenceException";
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        if (D.41229 != 0B) goto <D.41843>; else goto <D.41844>;
        <D.41843>:
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        D.41229->next = inst;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        inst->prev = D.41229;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        goto <D.41845>;
        <D.41844>:
        D.41228 = cfg->cbb;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        D.41229 = D.41228->last_ins;
        D.41228->code = D.41229;
        <D.41845>:
      }
      goto <D.41846>;
      <D.41831>:
      <D.41846>:
      <D.41829>:
      D.41219 = cfg->mempool;
      inst = mono_mempool_alloc (D.41219, 80);
      inst->data.op[1].const_val = 0;
      D.41847 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.41847;
      inst->prev = 0B;
      D.41848 = inst->prev;
      inst->next = D.41848;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.41849 = inst->sreg3;
      inst->sreg2 = D.41849;
      D.41850 = inst->sreg2;
      inst->sreg1 = D.41850;
      D.41224 = cfg->ip;
      inst->cil_code = D.41224;
      inst->dreg = vtable_reg;
      D.41248 = *args;
      D.41249 = D.41248->dreg;
      inst->sreg1 = D.41249;
      inst->data.op[0].const_val = 0;
      inst->type = 1;
      D.41851 = (unsigned char) __ins_flags;
      inst->flags = D.41851;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      if (D.41229 != 0B) goto <D.41852>; else goto <D.41853>;
      <D.41852>:
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      D.41229->next = inst;
      D.41228 = cfg->cbb;
      D.41229 = D.41228->last_ins;
      inst->prev = D.41229;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      goto <D.41854>;
      <D.41853>:
      D.41228 = cfg->cbb;
      D.41228 = cfg->cbb;
      D.41228->last_ins = inst;
      D.41229 = D.41228->last_ins;
      D.41228->code = D.41229;
      <D.41854>:
    }
    D.41219 = cfg->mempool;
    ins = mono_mempool_alloc (D.41219, 80);
    ins->data.op[1].const_val = 0;
    D.41438 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.41438;
    ins->prev = 0B;
    D.41439 = ins->prev;
    ins->next = D.41439;
    ins->opcode = 390;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.41440 = ins->sreg3;
    ins->sreg2 = D.41440;
    D.41441 = ins->sreg2;
    ins->sreg1 = D.41441;
    D.41224 = cfg->ip;
    ins->cil_code = D.41224;
    ins->dreg = dreg;
    ins->sreg1 = vtable_reg;
    ins->data.op[0].const_val = 42;
    ins->type = 1;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 != 0B) goto <D.41855>; else goto <D.41856>;
    <D.41855>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41229->next = ins;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    ins->prev = D.41229;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    goto <D.41857>;
    <D.41856>:
    D.41228 = cfg->cbb;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    D.41229 = D.41228->last_ins;
    D.41228->code = D.41229;
    <D.41857>:
    type_from_op (ins, 0B, 0B);
    D.41445 = ins;
    return D.41445;
  }
  <D.41824>:
  D.41211 = cmethod->name;
  D.41858 = strcmp (D.41211, "get_Length");
  if (D.41858 == 0) goto <D.41859>; else goto <D.41860>;
  <D.41859>:
  {
    int dreg;

    D.41861 = alloc_ireg (cfg);
    dreg = (int) D.41861;
    {
      int __ins_flags;

      __ins_flags = 32;
      D.41862 = __ins_flags & 32;
      if (D.41862 != 0) goto <D.41863>; else goto <D.41864>;
      <D.41863>:
      D.41240 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.41241 = D.41240 & 144115188075855872;
      if (D.41241 != 0) goto <D.41865>; else goto <D.41866>;
      <D.41865>:
      {
        struct MonoInst * inst;

        D.41219 = cfg->mempool;
        inst = mono_mempool_alloc (D.41219, 80);
        inst->data.op[1].const_val = 0;
        D.41867 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.41867;
        inst->prev = 0B;
        D.41868 = inst->prev;
        inst->next = D.41868;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.41869 = inst->sreg3;
        inst->sreg2 = D.41869;
        D.41870 = inst->sreg2;
        inst->sreg1 = D.41870;
        D.41224 = cfg->ip;
        inst->cil_code = D.41224;
        inst->dreg = -1;
        D.41248 = *args;
        D.41249 = D.41248->dreg;
        inst->sreg1 = D.41249;
        inst->data.op[1].const_val = 0;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        if (D.41229 != 0B) goto <D.41871>; else goto <D.41872>;
        <D.41871>:
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        D.41229->next = inst;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        inst->prev = D.41229;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        goto <D.41873>;
        <D.41872>:
        D.41228 = cfg->cbb;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        D.41229 = D.41228->last_ins;
        D.41228->code = D.41229;
        <D.41873>:
      }
      {
        struct MonoInst * inst;

        D.41219 = cfg->mempool;
        inst = mono_mempool_alloc (D.41219, 80);
        inst->data.op[1].const_val = 0;
        D.41874 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.41874;
        inst->prev = 0B;
        D.41875 = inst->prev;
        inst->next = D.41875;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.41876 = inst->sreg3;
        inst->sreg2 = D.41876;
        D.41877 = inst->sreg2;
        inst->sreg1 = D.41877;
        D.41224 = cfg->ip;
        inst->cil_code = D.41224;
        inst->data.op[1].p = "NullReferenceException";
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        if (D.41229 != 0B) goto <D.41878>; else goto <D.41879>;
        <D.41878>:
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        D.41229->next = inst;
        D.41228 = cfg->cbb;
        D.41229 = D.41228->last_ins;
        inst->prev = D.41229;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        goto <D.41880>;
        <D.41879>:
        D.41228 = cfg->cbb;
        D.41228 = cfg->cbb;
        D.41228->last_ins = inst;
        D.41229 = D.41228->last_ins;
        D.41228->code = D.41229;
        <D.41880>:
      }
      goto <D.41881>;
      <D.41866>:
      <D.41881>:
      <D.41864>:
      D.41219 = cfg->mempool;
      ins = mono_mempool_alloc (D.41219, 80);
      ins->data.op[1].const_val = 0;
      D.41438 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.41438;
      ins->prev = 0B;
      D.41439 = ins->prev;
      ins->next = D.41439;
      ins->opcode = 393;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.41440 = ins->sreg3;
      ins->sreg2 = D.41440;
      D.41441 = ins->sreg2;
      ins->sreg1 = D.41441;
      D.41224 = cfg->ip;
      ins->cil_code = D.41224;
      ins->dreg = dreg;
      D.41248 = *args;
      D.41249 = D.41248->dreg;
      ins->sreg1 = D.41249;
      ins->data.op[0].const_val = 24;
      ins->type = 1;
      D.41882 = (unsigned char) __ins_flags;
      ins->flags = D.41882;
    }
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 != 0B) goto <D.41883>; else goto <D.41884>;
    <D.41883>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41229->next = ins;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    ins->prev = D.41229;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    goto <D.41885>;
    <D.41884>:
    D.41228 = cfg->cbb;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    D.41229 = D.41228->last_ins;
    D.41228->code = D.41229;
    <D.41885>:
    type_from_op (ins, 0B, 0B);
    D.41445 = ins;
    return D.41445;
  }
  <D.41860>:
  D.41445 = 0B;
  return D.41445;
  <D.41548>:
  D.41207 = cmethod->klass;
  runtime_helpers_class.344 = runtime_helpers_class;
  if (D.41207 == runtime_helpers_class.344) goto <D.41886>; else goto <D.41887>;
  <D.41886>:
  D.41211 = cmethod->name;
  D.41888 = strcmp (D.41211, "get_OffsetToStringData");
  if (D.41888 == 0) goto <D.41889>; else goto <D.41890>;
  <D.41889>:
  D.41219 = cfg->mempool;
  ins = mono_mempool_alloc (D.41219, 80);
  ins->data.op[1].const_val = 0;
  D.41438 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.41438;
  ins->prev = 0B;
  D.41439 = ins->prev;
  ins->next = D.41439;
  ins->opcode = 362;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.41440 = ins->sreg3;
  ins->sreg2 = D.41440;
  D.41441 = ins->sreg2;
  ins->sreg1 = D.41441;
  D.41224 = cfg->ip;
  ins->cil_code = D.41224;
  ins->data.op[0].const_val = 20;
  ins->type = 1;
  D.41891 = alloc_dreg (cfg, 1);
  D.41892 = (int) D.41891;
  ins->dreg = D.41892;
  D.41228 = cfg->cbb;
  D.41229 = D.41228->last_ins;
  if (D.41229 != 0B) goto <D.41893>; else goto <D.41894>;
  <D.41893>:
  D.41228 = cfg->cbb;
  D.41229 = D.41228->last_ins;
  D.41229->next = ins;
  D.41228 = cfg->cbb;
  D.41229 = D.41228->last_ins;
  ins->prev = D.41229;
  D.41228 = cfg->cbb;
  D.41228->last_ins = ins;
  goto <D.41895>;
  <D.41894>:
  D.41228 = cfg->cbb;
  D.41228 = cfg->cbb;
  D.41228->last_ins = ins;
  D.41229 = D.41228->last_ins;
  D.41228->code = D.41229;
  <D.41895>:
  D.41445 = ins;
  return D.41445;
  <D.41890>:
  D.41445 = 0B;
  return D.41445;
  <D.41887>:
  D.41207 = cmethod->klass;
  D.41896 = mono_defaults.thread_class;
  if (D.41207 == D.41896) goto <D.41897>; else goto <D.41898>;
  <D.41897>:
  D.41211 = cmethod->name;
  D.41899 = strcmp (D.41211, "SpinWait_nop");
  if (D.41899 == 0) goto <D.41900>; else goto <D.41901>;
  <D.41900>:
  D.41219 = cfg->mempool;
  ins = mono_mempool_alloc (D.41219, 80);
  ins->data.op[1].const_val = 0;
  D.41438 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.41438;
  ins->prev = 0B;
  D.41439 = ins->prev;
  ins->next = D.41439;
  ins->opcode = 318;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.41440 = ins->sreg3;
  ins->sreg2 = D.41440;
  D.41441 = ins->sreg2;
  ins->sreg1 = D.41441;
  D.41224 = cfg->ip;
  ins->cil_code = D.41224;
  D.41228 = cfg->cbb;
  D.41229 = D.41228->last_ins;
  if (D.41229 != 0B) goto <D.41902>; else goto <D.41903>;
  <D.41902>:
  D.41228 = cfg->cbb;
  D.41229 = D.41228->last_ins;
  D.41229->next = ins;
  D.41228 = cfg->cbb;
  D.41229 = D.41228->last_ins;
  ins->prev = D.41229;
  D.41228 = cfg->cbb;
  D.41228->last_ins = ins;
  goto <D.41904>;
  <D.41903>:
  D.41228 = cfg->cbb;
  D.41228 = cfg->cbb;
  D.41228->last_ins = ins;
  D.41229 = D.41228->last_ins;
  D.41228->code = D.41229;
  <D.41904>:
  D.41445 = ins;
  return D.41445;
  <D.41901>:
  D.41211 = cmethod->name;
  D.41905 = strcmp (D.41211, "MemoryBarrier");
  if (D.41905 == 0) goto <D.41906>; else goto <D.41907>;
  <D.41906>:
  D.41445 = emit_memory_barrier (cfg, 4);
  return D.41445;
  <D.41907>:
  goto <D.41908>;
  <D.41898>:
  D.41207 = cmethod->klass;
  D.41909 = mono_defaults.monitor_class;
  if (D.41207 == D.41909) goto <D.41910>; else goto <D.41911>;
  <D.41910>:
  goto <D.41912>;
  <D.41911>:
  D.41207 = cmethod->klass;
  D.41915 = D.41207->image;
  D.41205 = mono_defaults.corlib;
  if (D.41915 == D.41205) goto <D.41916>; else goto <D.41913>;
  <D.41916>:
  D.41207 = cmethod->klass;
  D.41917 = D.41207->name_space;
  D.41918 = strcmp (D.41917, "System.Threading");
  if (D.41918 == 0) goto <D.41919>; else goto <D.41913>;
  <D.41919>:
  D.41207 = cmethod->klass;
  D.41920 = D.41207->name;
  D.41921 = strcmp (D.41920, "Interlocked");
  if (D.41921 == 0) goto <D.41922>; else goto <D.41913>;
  <D.41922>:
  ins = 0B;
  D.41211 = cmethod->name;
  D.41923 = strcmp (D.41211, "Read");
  if (D.41923 == 0) goto <D.41924>; else goto <D.41925>;
  <D.41924>:
  D.41926 = fsig->params[0];
  D.41927 = D.41926->type;
  if (D.41927 == 10) goto <D.41928>; else goto <D.41929>;
  <D.41928>:
  D.41219 = cfg->mempool;
  ins = mono_mempool_alloc (D.41219, 80);
  ins->data.op[1].const_val = 0;
  D.41438 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.41438;
  ins->prev = 0B;
  D.41439 = ins->prev;
  ins->next = D.41439;
  ins->opcode = 395;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.41440 = ins->sreg3;
  ins->sreg2 = D.41440;
  D.41441 = ins->sreg2;
  ins->sreg1 = D.41441;
  D.41224 = cfg->ip;
  ins->cil_code = D.41224;
  D.41930 = mono_alloc_preg (cfg);
  D.41931 = (int) D.41930;
  ins->dreg = D.41931;
  D.41248 = *args;
  D.41249 = D.41248->dreg;
  ins->sreg1 = D.41249;
  ins->data.op[0].const_val = 0;
  D.41228 = cfg->cbb;
  D.41229 = D.41228->last_ins;
  if (D.41229 != 0B) goto <D.41932>; else goto <D.41933>;
  <D.41932>:
  D.41228 = cfg->cbb;
  D.41229 = D.41228->last_ins;
  D.41229->next = ins;
  D.41228 = cfg->cbb;
  D.41229 = D.41228->last_ins;
  ins->prev = D.41229;
  D.41228 = cfg->cbb;
  D.41228->last_ins = ins;
  goto <D.41934>;
  <D.41933>:
  D.41228 = cfg->cbb;
  D.41228 = cfg->cbb;
  D.41228->last_ins = ins;
  D.41229 = D.41228->last_ins;
  D.41228->code = D.41229;
  <D.41934>:
  <D.41929>:
  <D.41925>:
  D.41211 = cmethod->name;
  D.41935 = strcmp (D.41211, "Increment");
  if (D.41935 == 0) goto <D.41936>; else goto <D.41937>;
  <D.41936>:
  {
    struct MonoInst * ins_iconst;
    guint32 opcode;

    opcode = 0;
    D.41926 = fsig->params[0];
    D.41927 = D.41926->type;
    if (D.41927 == 8) goto <D.41938>; else goto <D.41939>;
    <D.41938>:
    opcode = 804;
    cfg->has_atomic_add_new_i4 = 1;
    goto <D.41940>;
    <D.41939>:
    D.41926 = fsig->params[0];
    D.41927 = D.41926->type;
    if (D.41927 == 10) goto <D.41941>; else goto <D.41942>;
    <D.41941>:
    opcode = 809;
    <D.41942>:
    <D.41940>:
    if (opcode != 0) goto <D.41943>; else goto <D.41944>;
    <D.41943>:
    D.41219 = cfg->mempool;
    ins_iconst = mono_mempool_alloc (D.41219, 80);
    ins_iconst->data.op[1].const_val = 0;
    D.41945 = ins_iconst->data.op[1].const_val;
    ins_iconst->data.op[0].const_val = D.41945;
    ins_iconst->prev = 0B;
    D.41946 = ins_iconst->prev;
    ins_iconst->next = D.41946;
    ins_iconst->opcode = 362;
    ins_iconst->flags = 0;
    ins_iconst->type = 0;
    ins_iconst->dreg = -1;
    ins_iconst->sreg3 = -1;
    D.41947 = ins_iconst->sreg3;
    ins_iconst->sreg2 = D.41947;
    D.41948 = ins_iconst->sreg2;
    ins_iconst->sreg1 = D.41948;
    D.41224 = cfg->ip;
    ins_iconst->cil_code = D.41224;
    ins_iconst->data.op[0].const_val = 1;
    D.41949 = mono_alloc_ireg (cfg);
    D.41950 = (int) D.41949;
    ins_iconst->dreg = D.41950;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 != 0B) goto <D.41951>; else goto <D.41952>;
    <D.41951>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41229->next = ins_iconst;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    ins_iconst->prev = D.41229;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins_iconst;
    goto <D.41953>;
    <D.41952>:
    D.41228 = cfg->cbb;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins_iconst;
    D.41229 = D.41228->last_ins;
    D.41228->code = D.41229;
    <D.41953>:
    D.41219 = cfg->mempool;
    ins = mono_mempool_alloc (D.41219, 80);
    ins->data.op[1].const_val = 0;
    D.41438 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.41438;
    ins->prev = 0B;
    D.41439 = ins->prev;
    ins->next = D.41439;
    D.41954 = (short unsigned int) opcode;
    ins->opcode = D.41954;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.41440 = ins->sreg3;
    ins->sreg2 = D.41440;
    D.41441 = ins->sreg2;
    ins->sreg1 = D.41441;
    D.41224 = cfg->ip;
    ins->cil_code = D.41224;
    D.41955 = mono_alloc_ireg (cfg);
    D.41956 = (int) D.41955;
    ins->dreg = D.41956;
    D.41248 = *args;
    D.41249 = D.41248->dreg;
    ins->sreg1 = D.41249;
    ins->data.op[0].const_val = 0;
    D.41957 = ins_iconst->dreg;
    ins->sreg2 = D.41957;
    if (opcode == 804) goto <D.41959>; else goto <D.41960>;
    <D.41959>:
    iftmp.346 = 1;
    goto <D.41961>;
    <D.41960>:
    iftmp.346 = 2;
    <D.41961>:
    ins->type = iftmp.346;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 != 0B) goto <D.41962>; else goto <D.41963>;
    <D.41962>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41229->next = ins;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    ins->prev = D.41229;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    goto <D.41964>;
    <D.41963>:
    D.41228 = cfg->cbb;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    D.41229 = D.41228->last_ins;
    D.41228->code = D.41229;
    <D.41964>:
    <D.41944>:
  }
  goto <D.41965>;
  <D.41937>:
  D.41211 = cmethod->name;
  D.41966 = strcmp (D.41211, "Decrement");
  if (D.41966 == 0) goto <D.41967>; else goto <D.41968>;
  <D.41967>:
  {
    struct MonoInst * ins_iconst;
    guint32 opcode;

    opcode = 0;
    D.41926 = fsig->params[0];
    D.41927 = D.41926->type;
    if (D.41927 == 8) goto <D.41969>; else goto <D.41970>;
    <D.41969>:
    opcode = 804;
    cfg->has_atomic_add_new_i4 = 1;
    goto <D.41971>;
    <D.41970>:
    D.41926 = fsig->params[0];
    D.41927 = D.41926->type;
    if (D.41927 == 10) goto <D.41972>; else goto <D.41973>;
    <D.41972>:
    opcode = 809;
    <D.41973>:
    <D.41971>:
    if (opcode != 0) goto <D.41974>; else goto <D.41975>;
    <D.41974>:
    D.41219 = cfg->mempool;
    ins_iconst = mono_mempool_alloc (D.41219, 80);
    ins_iconst->data.op[1].const_val = 0;
    D.41976 = ins_iconst->data.op[1].const_val;
    ins_iconst->data.op[0].const_val = D.41976;
    ins_iconst->prev = 0B;
    D.41977 = ins_iconst->prev;
    ins_iconst->next = D.41977;
    ins_iconst->opcode = 362;
    ins_iconst->flags = 0;
    ins_iconst->type = 0;
    ins_iconst->dreg = -1;
    ins_iconst->sreg3 = -1;
    D.41978 = ins_iconst->sreg3;
    ins_iconst->sreg2 = D.41978;
    D.41979 = ins_iconst->sreg2;
    ins_iconst->sreg1 = D.41979;
    D.41224 = cfg->ip;
    ins_iconst->cil_code = D.41224;
    ins_iconst->data.op[0].const_val = -1;
    D.41980 = mono_alloc_ireg (cfg);
    D.41981 = (int) D.41980;
    ins_iconst->dreg = D.41981;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 != 0B) goto <D.41982>; else goto <D.41983>;
    <D.41982>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41229->next = ins_iconst;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    ins_iconst->prev = D.41229;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins_iconst;
    goto <D.41984>;
    <D.41983>:
    D.41228 = cfg->cbb;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins_iconst;
    D.41229 = D.41228->last_ins;
    D.41228->code = D.41229;
    <D.41984>:
    D.41219 = cfg->mempool;
    ins = mono_mempool_alloc (D.41219, 80);
    ins->data.op[1].const_val = 0;
    D.41438 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.41438;
    ins->prev = 0B;
    D.41439 = ins->prev;
    ins->next = D.41439;
    D.41985 = (short unsigned int) opcode;
    ins->opcode = D.41985;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.41440 = ins->sreg3;
    ins->sreg2 = D.41440;
    D.41441 = ins->sreg2;
    ins->sreg1 = D.41441;
    D.41224 = cfg->ip;
    ins->cil_code = D.41224;
    D.41986 = mono_alloc_ireg (cfg);
    D.41987 = (int) D.41986;
    ins->dreg = D.41987;
    D.41248 = *args;
    D.41249 = D.41248->dreg;
    ins->sreg1 = D.41249;
    ins->data.op[0].const_val = 0;
    D.41988 = ins_iconst->dreg;
    ins->sreg2 = D.41988;
    if (opcode == 804) goto <D.41990>; else goto <D.41991>;
    <D.41990>:
    iftmp.347 = 1;
    goto <D.41992>;
    <D.41991>:
    iftmp.347 = 2;
    <D.41992>:
    ins->type = iftmp.347;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 != 0B) goto <D.41993>; else goto <D.41994>;
    <D.41993>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41229->next = ins;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    ins->prev = D.41229;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    goto <D.41995>;
    <D.41994>:
    D.41228 = cfg->cbb;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    D.41229 = D.41228->last_ins;
    D.41228->code = D.41229;
    <D.41995>:
    <D.41975>:
  }
  goto <D.41996>;
  <D.41968>:
  D.41211 = cmethod->name;
  D.41997 = strcmp (D.41211, "Add");
  if (D.41997 == 0) goto <D.41998>; else goto <D.41999>;
  <D.41998>:
  {
    guint32 opcode;

    opcode = 0;
    D.41926 = fsig->params[0];
    D.41927 = D.41926->type;
    if (D.41927 == 8) goto <D.42000>; else goto <D.42001>;
    <D.42000>:
    opcode = 804;
    cfg->has_atomic_add_new_i4 = 1;
    goto <D.42002>;
    <D.42001>:
    D.41926 = fsig->params[0];
    D.41927 = D.41926->type;
    if (D.41927 == 10) goto <D.42003>; else goto <D.42004>;
    <D.42003>:
    opcode = 809;
    <D.42004>:
    <D.42002>:
    if (opcode != 0) goto <D.42005>; else goto <D.42006>;
    <D.42005>:
    D.41219 = cfg->mempool;
    ins = mono_mempool_alloc (D.41219, 80);
    ins->data.op[1].const_val = 0;
    D.41438 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.41438;
    ins->prev = 0B;
    D.41439 = ins->prev;
    ins->next = D.41439;
    D.42007 = (short unsigned int) opcode;
    ins->opcode = D.42007;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.41440 = ins->sreg3;
    ins->sreg2 = D.41440;
    D.41441 = ins->sreg2;
    ins->sreg1 = D.41441;
    D.41224 = cfg->ip;
    ins->cil_code = D.41224;
    D.42008 = mono_alloc_ireg (cfg);
    D.42009 = (int) D.42008;
    ins->dreg = D.42009;
    D.41248 = *args;
    D.41249 = D.41248->dreg;
    ins->sreg1 = D.41249;
    ins->data.op[0].const_val = 0;
    D.41225 = args + 8;
    D.41226 = *D.41225;
    D.41227 = D.41226->dreg;
    ins->sreg2 = D.41227;
    if (opcode == 804) goto <D.42011>; else goto <D.42012>;
    <D.42011>:
    iftmp.348 = 1;
    goto <D.42013>;
    <D.42012>:
    iftmp.348 = 2;
    <D.42013>:
    ins->type = iftmp.348;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 != 0B) goto <D.42014>; else goto <D.42015>;
    <D.42014>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41229->next = ins;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    ins->prev = D.41229;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    goto <D.42016>;
    <D.42015>:
    D.41228 = cfg->cbb;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    D.41229 = D.41228->last_ins;
    D.41228->code = D.41229;
    <D.42016>:
    <D.42006>:
  }
  <D.41999>:
  <D.41996>:
  <D.41965>:
  D.41211 = cmethod->name;
  D.42017 = strcmp (D.41211, "Exchange");
  if (D.42017 == 0) goto <D.42018>; else goto <D.42019>;
  <D.42018>:
  {
    guint32 opcode;
    gboolean is_ref;

    D.41926 = fsig->params[0];
    D.41927 = D.41926->type;
    D.42020 = D.41927 == 28;
    is_ref = (gboolean) D.42020;
    D.41926 = fsig->params[0];
    D.41927 = D.41926->type;
    if (D.41927 == 8) goto <D.42021>; else goto <D.42022>;
    <D.42021>:
    opcode = 807;
    cfg->has_atomic_exchange_i4 = 1;
    goto <D.42023>;
    <D.42022>:
    if (is_ref != 0) goto <D.42024>; else goto <D.42027>;
    <D.42027>:
    D.41926 = fsig->params[0];
    D.41927 = D.41926->type;
    if (D.41927 == 10) goto <D.42024>; else goto <D.42028>;
    <D.42028>:
    D.41926 = fsig->params[0];
    D.41927 = D.41926->type;
    if (D.41927 == 24) goto <D.42024>; else goto <D.42025>;
    <D.42024>:
    opcode = 812;
    goto <D.42026>;
    <D.42025>:
    D.41445 = 0B;
    return D.41445;
    <D.42026>:
    <D.42023>:
    D.41219 = cfg->mempool;
    ins = mono_mempool_alloc (D.41219, 80);
    ins->data.op[1].const_val = 0;
    D.41438 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.41438;
    ins->prev = 0B;
    D.41439 = ins->prev;
    ins->next = D.41439;
    D.42029 = (short unsigned int) opcode;
    ins->opcode = D.42029;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.41440 = ins->sreg3;
    ins->sreg2 = D.41440;
    D.41441 = ins->sreg2;
    ins->sreg1 = D.41441;
    D.41224 = cfg->ip;
    ins->cil_code = D.41224;
    if (is_ref != 0) goto <D.42031>; else goto <D.42032>;
    <D.42031>:
    D.42033 = mono_alloc_ireg_ref (cfg);
    iftmp.349 = (gint32) D.42033;
    goto <D.42034>;
    <D.42032>:
    D.42035 = mono_alloc_ireg (cfg);
    iftmp.349 = (gint32) D.42035;
    <D.42034>:
    ins->dreg = iftmp.349;
    D.41248 = *args;
    D.41249 = D.41248->dreg;
    ins->sreg1 = D.41249;
    ins->data.op[0].const_val = 0;
    D.41225 = args + 8;
    D.41226 = *D.41225;
    D.41227 = D.41226->dreg;
    ins->sreg2 = D.41227;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    if (D.41229 != 0B) goto <D.42036>; else goto <D.42037>;
    <D.42036>:
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    D.41229->next = ins;
    D.41228 = cfg->cbb;
    D.41229 = D.41228->last_ins;
    ins->prev = D.41229;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    goto <D.42038>;
    <D.42037>:
    D.41228 = cfg->cbb;
    D.41228 = cfg->cbb;
    D.41228->last_ins = ins;
    D.41229 = D.41228->last_ins;
    D.41228->code = D.41229;
    <D.42038>:
    D.41926 = fsig->params[0];
    D.41927 = D.41926->type;
    D.42039 = (int) D.41927;
    switch (D.42039) <default: <D.26931>, case 8: <D.26926>, case 10: <D.26928>, case 24: <D.26929>, case 28: <D.26930>>
    <D.26926>:
    ins->type = 1;
    goto <D.26927>;
    <D.26928>:
    <D.26929>:
    ins->type = 2;
    goto <D.26927>;
    <D.26930>:
    ins->type = 6;
    goto <D.26927>;
    <D.26931>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 5462);
    <D.26927>:
    D.41664 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.42040 = D.41664 & 8;
    if (D.42040 != 0) goto <D.42041>; else goto <D.42042>;
    <D.42041>:
    if (is_ref != 0) goto <D.42043>; else goto <D.42044>;
    <D.42043>:
    D.41248 = *args;
    D.41225 = args + 8;
    D.41226 = *D.41225;
    emit_write_barrier (cfg, D.41248, D.41226);
    <D.42044>:
    <D.42042>:
  }
  <D.42019>:
  D.41211 = cmethod->name;
  D.42045 = strcmp (D.41211, "MemoryBarrier");
  if (D.42045 == 0) goto <D.42046>; else goto <D.42047>;
  <D.42046>:
  ins = emit_memory_barrier (cfg, 4);
  <D.42047>:
  if (ins != 0B) goto <D.42048>; else goto <D.42049>;
  <D.42048>:
  D.41445 = ins;
  return D.41445;
  <D.42049>:
  goto <D.41914>;
  <D.41913>:
  D.41207 = cmethod->klass;
  D.41915 = D.41207->image;
  D.41205 = mono_defaults.corlib;
  if (D.41915 == D.41205) goto <D.42050>; else goto <D.42051>;
  <D.42050>:
  D.41211 = cmethod->name;
  D.41556 = *D.41211;
  if (D.41556 == 66) goto <D.42052>; else goto <D.42053>;
  <D.42052>:
  D.41211 = cmethod->name;
  D.42054 = strcmp (D.41211, "Break");
  if (D.42054 == 0) goto <D.42055>; else goto <D.42056>;
  <D.42055>:
  D.41207 = cmethod->klass;
  D.41920 = D.41207->name;
  D.42057 = strcmp (D.41920, "Debugger");
  if (D.42057 == 0) goto <D.42058>; else goto <D.42059>;
  <D.42058>:
  D.42060 = cfg->method;
  D.42061 = should_insert_brekpoint (D.42060);
  if (D.42061 != 0) goto <D.42062>; else goto <D.42063>;
  <D.42062>:
  ins = mono_emit_jit_icall (cfg, mono_debugger_agent_user_break, 0B);
  goto <D.42064>;
  <D.42063>:
  D.41219 = cfg->mempool;
  ins = mono_mempool_alloc (D.41219, 80);
  ins->data.op[1].const_val = 0;
  D.41438 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.41438;
  ins->prev = 0B;
  D.41439 = ins->prev;
  ins->next = D.41439;
  ins->opcode = 316;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.41440 = ins->sreg3;
  ins->sreg2 = D.41440;
  D.41441 = ins->sreg2;
  ins->sreg1 = D.41441;
  D.41224 = cfg->ip;
  ins->cil_code = D.41224;
  D.41228 = cfg->cbb;
  D.41229 = D.41228->last_ins;
  if (D.41229 != 0B) goto <D.42065>; else goto <D.42066>;
  <D.42065>:
  D.41228 = cfg->cbb;
  D.41229 = D.41228->last_ins;
  D.41229->next = ins;
  D.41228 = cfg->cbb;
  D.41229 = D.41228->last_ins;
  ins->prev = D.41229;
  D.41228 = cfg->cbb;
  D.41228->last_ins = ins;
  goto <D.42067>;
  <D.42066>:
  D.41228 = cfg->cbb;
  D.41228 = cfg->cbb;
  D.41228->last_ins = ins;
  D.41229 = D.41228->last_ins;
  D.41228->code = D.41229;
  <D.42067>:
  <D.42064>:
  D.41445 = ins;
  return D.41445;
  <D.42059>:
  <D.42056>:
  <D.42053>:
  D.41211 = cmethod->name;
  D.41556 = *D.41211;
  if (D.41556 == 103) goto <D.42068>; else goto <D.42069>;
  <D.42068>:
  D.41211 = cmethod->name;
  D.42070 = strcmp (D.41211, "get_IsRunningOnWindows");
  if (D.42070 == 0) goto <D.42071>; else goto <D.42072>;
  <D.42071>:
  D.41207 = cmethod->klass;
  D.41920 = D.41207->name;
  D.42073 = strcmp (D.41920, "Environment");
  if (D.42073 == 0) goto <D.42074>; else goto <D.42075>;
  <D.42074>:
  D.41219 = cfg->mempool;
  ins = mono_mempool_alloc (D.41219, 80);
  ins->data.op[1].const_val = 0;
  D.41438 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.41438;
  ins->prev = 0B;
  D.41439 = ins->prev;
  ins->next = D.41439;
  ins->opcode = 362;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.41440 = ins->sreg3;
  ins->sreg2 = D.41440;
  D.41441 = ins->sreg2;
  ins->sreg1 = D.41441;
  D.41224 = cfg->ip;
  ins->cil_code = D.41224;
  ins->data.op[0].const_val = 0;
  ins->type = 1;
  D.42076 = alloc_dreg (cfg, 1);
  D.42077 = (int) D.42076;
  ins->dreg = D.42077;
  D.41228 = cfg->cbb;
  D.41229 = D.41228->last_ins;
  if (D.41229 != 0B) goto <D.42078>; else goto <D.42079>;
  <D.42078>:
  D.41228 = cfg->cbb;
  D.41229 = D.41228->last_ins;
  D.41229->next = ins;
  D.41228 = cfg->cbb;
  D.41229 = D.41228->last_ins;
  ins->prev = D.41229;
  D.41228 = cfg->cbb;
  D.41228->last_ins = ins;
  goto <D.42080>;
  <D.42079>:
  D.41228 = cfg->cbb;
  D.41228 = cfg->cbb;
  D.41228->last_ins = ins;
  D.41229 = D.41228->last_ins;
  D.41228->code = D.41229;
  <D.42080>:
  D.41445 = ins;
  return D.41445;
  <D.42075>:
  <D.42072>:
  <D.42069>:
  goto <D.42081>;
  <D.42051>:
  D.41207 = cmethod->klass;
  D.42082 = mono_defaults.math_class;
  if (D.41207 == D.42082) goto <D.42083>; else goto <D.42084>;
  <D.42083>:
  goto <D.42085>;
  <D.42084>:
  D.41207 = cmethod->klass;
  D.41915 = D.41207->image;
  D.42086 = D.41915->assembly;
  D.42087 = D.42086->aname.name;
  D.42088 = strcmp (D.42087, "MonoMac");
  if (D.42088 == 0) goto <D.42089>; else goto <D.42090>;
  <D.42090>:
  D.41207 = cmethod->klass;
  D.41915 = D.41207->image;
  D.42086 = D.41915->assembly;
  D.42087 = D.42086->aname.name;
  D.42091 = strcmp (D.42087, "monotouch");
  if (D.42091 == 0) goto <D.42092>; else goto <D.42093>;
  <D.42092>:
  D.41207 = cmethod->klass;
  D.41920 = D.41207->name;
  D.42094 = strcmp (D.41920, "Selector");
  if (D.42094 == 0) goto <D.42095>; else goto <D.42096>;
  <D.42095>:
  D.41211 = cmethod->name;
  D.42097 = strcmp (D.41211, "GetHandle");
  if (D.42097 == 0) goto <D.42098>; else goto <D.42099>;
  <D.42098>:
  D.41664 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.42100 = D.41664 & 33554432;
  if (D.42100 != 0) goto <D.42101>; else goto <D.42102>;
  <D.42101>:
  D.41248 = *args;
  D.42103 = D.41248->opcode;
  if (D.42103 == 734) goto <D.42104>; else goto <D.42105>;
  <D.42105>:
  D.41248 = *args;
  D.42103 = D.41248->opcode;
  if (D.42103 == 732) goto <D.42106>; else goto <D.42107>;
  <D.42106>:
  <D.42107>:
  <D.42104>:
  <D.42102>:
  <D.42099>:
  <D.42096>:
  <D.42093>:
  <D.42089>:
  <D.42085>:
  <D.42081>:
  <D.41914>:
  <D.41912>:
  <D.41908>:
  if (0 != 0) goto <D.42108>; else goto <D.42109>;
  <D.42108>:
  ins = llvm_emit_inst_for_method (cfg, cmethod, fsig, args);
  if (ins != 0B) goto <D.42110>; else goto <D.42111>;
  <D.42110>:
  D.41445 = ins;
  return D.41445;
  <D.42111>:
  <D.42109>:
  D.41445 = mono_arch_emit_inst_for_method (cfg, cmethod, fsig, args);
  return D.41445;
}


emit_array_generic_access (struct MonoCompile * cfg, struct MonoMethodSignature * fsig, struct MonoInst * * args, int is_set)
{
  struct MonoType * D.42113;
  struct MonoInst * D.42114;
  struct MonoInst * * D.42115;
  struct MonoInst * D.42116;
  struct MonoMemPool * D.42119;
  long int D.42120;
  struct MonoInst * D.42121;
  struct MonoType * D.42122;
  unsigned int D.42123;
  short unsigned int D.42124;
  int D.42125;
  int D.42126;
  const unsigned char * D.42127;
  struct MonoInst * * D.42128;
  struct MonoInst * D.42129;
  int D.42130;
  unsigned char D.42131;
  <unnamed type> D.42132;
  unsigned int D.42133;
  int D.42134;
  struct MonoBasicBlock * D.42135;
  struct MonoInst * D.42136;
  long int D.42140;
  struct MonoInst * D.42141;
  unsigned int D.42142;
  short unsigned int D.42143;
  int D.42144;
  int D.42145;
  int D.42146;
  int D.42147;
  struct MonoClass * D.42148;
  int D.42152;
  unsigned int D.42156;
  short unsigned int D.42157;
  unsigned int D.42158;
  int D.42159;
  unsigned int D.42163;
  short unsigned int D.42164;
  struct MonoClass * D.42165;
  struct MonoInst * D.42169;
  struct MonoInst * addr;
  struct MonoInst * store;
  struct MonoInst * load;
  struct MonoClass * eklass;

  D.42113 = fsig->params[2];
  eklass = mono_class_from_mono_type (D.42113);
  D.42114 = *args;
  D.42115 = args + 8;
  D.42116 = *D.42115;
  addr = mini_emit_ldelema_1_ins (cfg, eklass, D.42114, D.42116, 0);
  if (is_set != 0) goto <D.42117>; else goto <D.42118>;
  <D.42117>:
  D.42119 = cfg->mempool;
  load = mono_mempool_alloc (D.42119, 80);
  load->data.op[1].const_val = 0;
  D.42120 = load->data.op[1].const_val;
  load->data.op[0].const_val = D.42120;
  load->prev = 0B;
  D.42121 = load->prev;
  load->next = D.42121;
  D.42122 = &eklass->byval_arg;
  D.42123 = mono_type_to_load_membase (cfg, D.42122);
  D.42124 = (short unsigned int) D.42123;
  load->opcode = D.42124;
  load->flags = 0;
  load->type = 0;
  load->dreg = -1;
  load->sreg3 = -1;
  D.42125 = load->sreg3;
  load->sreg2 = D.42125;
  D.42126 = load->sreg2;
  load->sreg1 = D.42126;
  D.42127 = cfg->ip;
  load->cil_code = D.42127;
  load->dreg = 0;
  D.42128 = args + 16;
  D.42129 = *D.42128;
  D.42130 = D.42129->dreg;
  load->sreg1 = D.42130;
  load->data.op[0].const_val = 0;
  load->type = 1;
  D.42122 = &eklass->byval_arg;
  type_to_eval_stack_type (cfg, D.42122, load);
  D.42131 = load->type;
  D.42132 = (<unnamed type>) D.42131;
  D.42133 = alloc_dreg (cfg, D.42132);
  D.42134 = (int) D.42133;
  load->dreg = D.42134;
  D.42135 = cfg->cbb;
  D.42136 = D.42135->last_ins;
  if (D.42136 != 0B) goto <D.42137>; else goto <D.42138>;
  <D.42137>:
  D.42135 = cfg->cbb;
  D.42136 = D.42135->last_ins;
  D.42136->next = load;
  D.42135 = cfg->cbb;
  D.42136 = D.42135->last_ins;
  load->prev = D.42136;
  D.42135 = cfg->cbb;
  D.42135->last_ins = load;
  goto <D.42139>;
  <D.42138>:
  D.42135 = cfg->cbb;
  D.42135 = cfg->cbb;
  D.42135->last_ins = load;
  D.42136 = D.42135->last_ins;
  D.42135->code = D.42136;
  <D.42139>:
  D.42119 = cfg->mempool;
  store = mono_mempool_alloc (D.42119, 80);
  store->data.op[1].const_val = 0;
  D.42140 = store->data.op[1].const_val;
  store->data.op[0].const_val = D.42140;
  store->prev = 0B;
  D.42141 = store->prev;
  store->next = D.42141;
  D.42122 = &eklass->byval_arg;
  D.42142 = mono_type_to_store_membase (cfg, D.42122);
  D.42143 = (short unsigned int) D.42142;
  store->opcode = D.42143;
  store->flags = 0;
  store->type = 0;
  store->dreg = -1;
  store->sreg3 = -1;
  D.42144 = store->sreg3;
  store->sreg2 = D.42144;
  D.42145 = store->sreg2;
  store->sreg1 = D.42145;
  D.42127 = cfg->ip;
  store->cil_code = D.42127;
  D.42146 = load->dreg;
  store->sreg1 = D.42146;
  D.42147 = addr->dreg;
  store->dreg = D.42147;
  store->data.op[0].const_val = 0;
  D.42122 = &eklass->byval_arg;
  type_to_eval_stack_type (cfg, D.42122, store);
  D.42122 = &eklass->byval_arg;
  D.42148 = mono_class_from_mono_type (D.42122);
  store->klass = D.42148;
  D.42135 = cfg->cbb;
  D.42136 = D.42135->last_ins;
  if (D.42136 != 0B) goto <D.42149>; else goto <D.42150>;
  <D.42149>:
  D.42135 = cfg->cbb;
  D.42136 = D.42135->last_ins;
  D.42136->next = store;
  D.42135 = cfg->cbb;
  D.42136 = D.42135->last_ins;
  store->prev = D.42136;
  D.42135 = cfg->cbb;
  D.42135->last_ins = store;
  goto <D.42151>;
  <D.42150>:
  D.42135 = cfg->cbb;
  D.42135 = cfg->cbb;
  D.42135->last_ins = store;
  D.42136 = D.42135->last_ins;
  D.42135->code = D.42136;
  <D.42151>:
  D.42113 = fsig->params[2];
  D.42152 = mini_type_is_reference (cfg, D.42113);
  if (D.42152 != 0) goto <D.42153>; else goto <D.42154>;
  <D.42153>:
  emit_write_barrier (cfg, addr, load);
  <D.42154>:
  goto <D.42155>;
  <D.42118>:
  D.42119 = cfg->mempool;
  load = mono_mempool_alloc (D.42119, 80);
  load->data.op[1].const_val = 0;
  D.42120 = load->data.op[1].const_val;
  load->data.op[0].const_val = D.42120;
  load->prev = 0B;
  D.42121 = load->prev;
  load->next = D.42121;
  D.42122 = &eklass->byval_arg;
  D.42156 = mono_type_to_load_membase (cfg, D.42122);
  D.42157 = (short unsigned int) D.42156;
  load->opcode = D.42157;
  load->flags = 0;
  load->type = 0;
  load->dreg = -1;
  load->sreg3 = -1;
  D.42125 = load->sreg3;
  load->sreg2 = D.42125;
  D.42126 = load->sreg2;
  load->sreg1 = D.42126;
  D.42127 = cfg->ip;
  load->cil_code = D.42127;
  load->dreg = 0;
  D.42147 = addr->dreg;
  load->sreg1 = D.42147;
  load->data.op[0].const_val = 0;
  load->type = 1;
  D.42122 = &eklass->byval_arg;
  type_to_eval_stack_type (cfg, D.42122, load);
  D.42131 = load->type;
  D.42132 = (<unnamed type>) D.42131;
  D.42158 = alloc_dreg (cfg, D.42132);
  D.42159 = (int) D.42158;
  load->dreg = D.42159;
  D.42135 = cfg->cbb;
  D.42136 = D.42135->last_ins;
  if (D.42136 != 0B) goto <D.42160>; else goto <D.42161>;
  <D.42160>:
  D.42135 = cfg->cbb;
  D.42136 = D.42135->last_ins;
  D.42136->next = load;
  D.42135 = cfg->cbb;
  D.42136 = D.42135->last_ins;
  load->prev = D.42136;
  D.42135 = cfg->cbb;
  D.42135->last_ins = load;
  goto <D.42162>;
  <D.42161>:
  D.42135 = cfg->cbb;
  D.42135 = cfg->cbb;
  D.42135->last_ins = load;
  D.42136 = D.42135->last_ins;
  D.42135->code = D.42136;
  <D.42162>:
  D.42119 = cfg->mempool;
  store = mono_mempool_alloc (D.42119, 80);
  store->data.op[1].const_val = 0;
  D.42140 = store->data.op[1].const_val;
  store->data.op[0].const_val = D.42140;
  store->prev = 0B;
  D.42141 = store->prev;
  store->next = D.42141;
  D.42122 = &eklass->byval_arg;
  D.42163 = mono_type_to_store_membase (cfg, D.42122);
  D.42164 = (short unsigned int) D.42163;
  store->opcode = D.42164;
  store->flags = 0;
  store->type = 0;
  store->dreg = -1;
  store->sreg3 = -1;
  D.42144 = store->sreg3;
  store->sreg2 = D.42144;
  D.42145 = store->sreg2;
  store->sreg1 = D.42145;
  D.42127 = cfg->ip;
  store->cil_code = D.42127;
  D.42146 = load->dreg;
  store->sreg1 = D.42146;
  D.42128 = args + 16;
  D.42129 = *D.42128;
  D.42130 = D.42129->dreg;
  store->dreg = D.42130;
  store->data.op[0].const_val = 0;
  D.42122 = &eklass->byval_arg;
  type_to_eval_stack_type (cfg, D.42122, store);
  D.42122 = &eklass->byval_arg;
  D.42165 = mono_class_from_mono_type (D.42122);
  store->klass = D.42165;
  D.42135 = cfg->cbb;
  D.42136 = D.42135->last_ins;
  if (D.42136 != 0B) goto <D.42166>; else goto <D.42167>;
  <D.42166>:
  D.42135 = cfg->cbb;
  D.42136 = D.42135->last_ins;
  D.42136->next = store;
  D.42135 = cfg->cbb;
  D.42136 = D.42135->last_ins;
  store->prev = D.42136;
  D.42135 = cfg->cbb;
  D.42135->last_ins = store;
  goto <D.42168>;
  <D.42167>:
  D.42135 = cfg->cbb;
  D.42135 = cfg->cbb;
  D.42135->last_ins = store;
  D.42136 = D.42135->last_ins;
  D.42135->code = D.42136;
  <D.42168>:
  <D.42155>:
  D.42169 = store;
  return D.42169;
}


emit_get_rgctx_sig (struct MonoCompile * cfg, int context_used, struct MonoMethodSignature * sig, MonoRgctxInfoType rgctx_type)
{
  struct MonoMemPool * D.42171;
  struct MonoMethod * D.42172;
  int D.42173;
  struct MonoInst * D.42174;
  struct MonoJumpInfoRgctxEntry * entry;
  struct MonoInst * rgctx;

  D.42171 = cfg->mempool;
  D.42172 = cfg->current_method;
  D.42173 = context_used & 2;
  entry = mono_patch_info_rgctx_entry_new (D.42171, D.42172, D.42173, 44, sig, rgctx_type);
  D.42172 = cfg->current_method;
  rgctx = emit_get_rgctx (cfg, D.42172, context_used);
  D.42174 = emit_rgctx_fetch (cfg, rgctx, entry);
  return D.42174;
}


mini_emit_ldelema_ins (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoInst * * sp, unsigned char * ip, gboolean is_set)
{
  struct MonoMethodSignature * D.42176;
  short unsigned int D.42177;
  int D.42178;
  _Bool D.42179;
  int D.42180;
  struct MonoInst * D.42183;
  struct MonoClass * D.42184;
  struct MonoClass * D.42185;
  struct MonoInst * D.42186;
  struct MonoInst * * D.42187;
  struct MonoInst * D.42188;
  unsigned int D.42191;
  unsigned int D.42192;
  struct MonoInst * * D.42195;
  struct MonoInst * D.42196;
  int rank;
  struct MonoInst * addr;
  struct MonoMethod * addr_method;
  int element_size;

  D.42176 = mono_method_signature (cmethod);
  D.42177 = D.42176->param_count;
  D.42178 = (int) D.42177;
  D.42179 = is_set != 0;
  D.42180 = (int) D.42179;
  rank = D.42178 - D.42180;
  if (rank == 1) goto <D.42181>; else goto <D.42182>;
  <D.42181>:
  D.42184 = cmethod->klass;
  D.42185 = D.42184->element_class;
  D.42186 = *sp;
  D.42187 = sp + 8;
  D.42188 = *D.42187;
  D.42183 = mini_emit_ldelema_1_ins (cfg, D.42185, D.42186, D.42188, 1);
  return D.42183;
  <D.42182>:
  if (rank == 2) goto <D.42189>; else goto <D.42190>;
  <D.42189>:
  D.42191 = cfg->opt;
  D.42192 = D.42191 & 2048;
  if (D.42192 != 0) goto <D.42193>; else goto <D.42194>;
  <D.42193>:
  D.42184 = cmethod->klass;
  D.42185 = D.42184->element_class;
  D.42186 = *sp;
  D.42187 = sp + 8;
  D.42188 = *D.42187;
  D.42195 = sp + 16;
  D.42196 = *D.42195;
  D.42183 = mini_emit_ldelema_2_ins (cfg, D.42185, D.42186, D.42188, D.42196);
  return D.42183;
  <D.42194>:
  <D.42190>:
  D.42184 = cmethod->klass;
  D.42185 = D.42184->element_class;
  element_size = mono_class_array_element_size (D.42185);
  addr_method = mono_marshal_get_array_address (rank, element_size);
  addr = mono_emit_method_call (cfg, addr_method, sp, 0B);
  D.42183 = addr;
  return D.42183;
}


mini_emit_ldelema_2_ins (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * arr, struct MonoInst * index_ins1, struct MonoInst * index_ins2)
{
  unsigned int D.42198;
  unsigned int D.42199;
  unsigned int D.42200;
  unsigned int D.42201;
  unsigned int D.42202;
  unsigned int D.42203;
  unsigned int D.42204;
  unsigned int D.42205;
  unsigned int D.42206;
  unsigned int D.42207;
  unsigned int D.42208;
  int D.42209;
  unsigned int D.42213;
  struct MonoMemPool * D.42214;
  long int D.42215;
  struct MonoInst * D.42216;
  int D.42217;
  int D.42218;
  const unsigned char * D.42219;
  struct MonoBasicBlock * D.42220;
  struct MonoInst * D.42221;
  unsigned int D.42225;
  long int D.42226;
  struct MonoInst * D.42227;
  int D.42228;
  int D.42229;
  long int D.42233;
  struct MonoInst * D.42234;
  int D.42235;
  int D.42236;
  int D.42237;
  long int D.42241;
  struct MonoInst * D.42242;
  int D.42243;
  int D.42244;
  long int D.42248;
  struct MonoInst * D.42249;
  int D.42250;
  int D.42251;
  long int D.42255;
  struct MonoInst * D.42256;
  int D.42257;
  int D.42258;
  long int D.42262;
  struct MonoInst * D.42263;
  int D.42264;
  int D.42265;
  long int D.42269;
  struct MonoInst * D.42270;
  int D.42271;
  int D.42272;
  long int D.42276;
  struct MonoInst * D.42277;
  int D.42278;
  int D.42279;
  long int D.42283;
  struct MonoInst * D.42284;
  int D.42285;
  int D.42286;
  long int D.42290;
  struct MonoInst * D.42291;
  int D.42292;
  int D.42293;
  long int D.42297;
  struct MonoInst * D.42298;
  int D.42299;
  int D.42300;
  long int D.42304;
  struct MonoInst * D.42305;
  int D.42306;
  int D.42307;
  long int D.42311;
  struct MonoInst * D.42312;
  int D.42313;
  int D.42314;
  long int D.42318;
  struct MonoInst * D.42319;
  int D.42320;
  int D.42321;
  long int D.42325;
  struct MonoInst * D.42326;
  int D.42327;
  int D.42328;
  long int D.42329;
  long int D.42333;
  struct MonoInst * D.42334;
  int D.42335;
  int D.42336;
  long int D.42340;
  struct MonoInst * D.42341;
  int D.42342;
  int D.42343;
  struct MonoInst * D.42347;
  int bounds_reg;
  int add_reg;
  int mult_reg;
  int mult2_reg;
  int low1_reg;
  int low2_reg;
  int high1_reg;
  int high2_reg;
  int realidx1_reg;
  int realidx2_reg;
  int sum_reg;
  int index1;
  int index2;
  int tmpreg;
  struct MonoInst * ins;
  guint32 size;

  D.42198 = alloc_preg (cfg);
  bounds_reg = (int) D.42198;
  D.42199 = alloc_ireg_mp (cfg);
  add_reg = (int) D.42199;
  D.42200 = alloc_preg (cfg);
  mult_reg = (int) D.42200;
  D.42201 = alloc_preg (cfg);
  mult2_reg = (int) D.42201;
  D.42202 = alloc_preg (cfg);
  low1_reg = (int) D.42202;
  D.42203 = alloc_preg (cfg);
  low2_reg = (int) D.42203;
  D.42204 = alloc_preg (cfg);
  high1_reg = (int) D.42204;
  D.42205 = alloc_preg (cfg);
  high2_reg = (int) D.42205;
  D.42206 = alloc_preg (cfg);
  realidx1_reg = (int) D.42206;
  D.42207 = alloc_preg (cfg);
  realidx2_reg = (int) D.42207;
  D.42208 = alloc_preg (cfg);
  sum_reg = (int) D.42208;
  mono_class_init (klass);
  D.42209 = mono_class_array_element_size (klass);
  size = (guint32) D.42209;
  index1 = index_ins1->dreg;
  index2 = index_ins2->dreg;
  if (0 != 0) goto <D.42210>; else goto <D.42211>;
  <D.42210>:
  goto <D.42212>;
  <D.42211>:
  D.42213 = alloc_preg (cfg);
  tmpreg = (int) D.42213;
  {
    struct MonoInst * inst;

    D.42214 = cfg->mempool;
    inst = mono_mempool_alloc (D.42214, 80);
    inst->data.op[1].const_val = 0;
    D.42215 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42215;
    inst->prev = 0B;
    D.42216 = inst->prev;
    inst->next = D.42216;
    inst->opcode = 762;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42217 = inst->sreg3;
    inst->sreg2 = D.42217;
    D.42218 = inst->sreg2;
    inst->sreg1 = D.42218;
    D.42219 = cfg->ip;
    inst->cil_code = D.42219;
    inst->dreg = tmpreg;
    inst->sreg1 = index1;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    if (D.42221 != 0B) goto <D.42222>; else goto <D.42223>;
    <D.42222>:
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    D.42221->next = inst;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    inst->prev = D.42221;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    goto <D.42224>;
    <D.42223>:
    D.42220 = cfg->cbb;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    D.42221 = D.42220->last_ins;
    D.42220->code = D.42221;
    <D.42224>:
  }
  index1 = tmpreg;
  D.42225 = alloc_preg (cfg);
  tmpreg = (int) D.42225;
  {
    struct MonoInst * inst;

    D.42214 = cfg->mempool;
    inst = mono_mempool_alloc (D.42214, 80);
    inst->data.op[1].const_val = 0;
    D.42226 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42226;
    inst->prev = 0B;
    D.42227 = inst->prev;
    inst->next = D.42227;
    inst->opcode = 762;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42228 = inst->sreg3;
    inst->sreg2 = D.42228;
    D.42229 = inst->sreg2;
    inst->sreg1 = D.42229;
    D.42219 = cfg->ip;
    inst->cil_code = D.42219;
    inst->dreg = tmpreg;
    inst->sreg1 = index2;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    if (D.42221 != 0B) goto <D.42230>; else goto <D.42231>;
    <D.42230>:
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    D.42221->next = inst;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    inst->prev = D.42221;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    goto <D.42232>;
    <D.42231>:
    D.42220 = cfg->cbb;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    D.42221 = D.42220->last_ins;
    D.42220->code = D.42221;
    <D.42232>:
  }
  index2 = tmpreg;
  <D.42212>:
  {
    struct MonoInst * inst;

    D.42214 = cfg->mempool;
    inst = mono_mempool_alloc (D.42214, 80);
    inst->data.op[1].const_val = 0;
    D.42233 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42233;
    inst->prev = 0B;
    D.42234 = inst->prev;
    inst->next = D.42234;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42235 = inst->sreg3;
    inst->sreg2 = D.42235;
    D.42236 = inst->sreg2;
    inst->sreg1 = D.42236;
    D.42219 = cfg->ip;
    inst->cil_code = D.42219;
    inst->dreg = bounds_reg;
    D.42237 = arr->dreg;
    inst->sreg1 = D.42237;
    inst->data.op[0].const_val = 16;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    if (D.42221 != 0B) goto <D.42238>; else goto <D.42239>;
    <D.42238>:
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    D.42221->next = inst;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    inst->prev = D.42221;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    goto <D.42240>;
    <D.42239>:
    D.42220 = cfg->cbb;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    D.42221 = D.42220->last_ins;
    D.42220->code = D.42221;
    <D.42240>:
  }
  {
    struct MonoInst * inst;

    D.42214 = cfg->mempool;
    inst = mono_mempool_alloc (D.42214, 80);
    inst->data.op[1].const_val = 0;
    D.42241 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42241;
    inst->prev = 0B;
    D.42242 = inst->prev;
    inst->next = D.42242;
    inst->opcode = 393;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42243 = inst->sreg3;
    inst->sreg2 = D.42243;
    D.42244 = inst->sreg2;
    inst->sreg1 = D.42244;
    D.42219 = cfg->ip;
    inst->cil_code = D.42219;
    inst->dreg = low1_reg;
    inst->sreg1 = bounds_reg;
    inst->data.op[0].const_val = 4;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    if (D.42221 != 0B) goto <D.42245>; else goto <D.42246>;
    <D.42245>:
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    D.42221->next = inst;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    inst->prev = D.42221;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    goto <D.42247>;
    <D.42246>:
    D.42220 = cfg->cbb;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    D.42221 = D.42220->last_ins;
    D.42220->code = D.42221;
    <D.42247>:
  }
  {
    struct MonoInst * inst;

    D.42214 = cfg->mempool;
    inst = mono_mempool_alloc (D.42214, 80);
    inst->data.op[1].const_val = 0;
    D.42248 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42248;
    inst->prev = 0B;
    D.42249 = inst->prev;
    inst->next = D.42249;
    inst->opcode = 480;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42250 = inst->sreg3;
    inst->sreg2 = D.42250;
    D.42251 = inst->sreg2;
    inst->sreg1 = D.42251;
    D.42219 = cfg->ip;
    inst->cil_code = D.42219;
    inst->dreg = realidx1_reg;
    inst->sreg1 = index1;
    inst->sreg2 = low1_reg;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    if (D.42221 != 0B) goto <D.42252>; else goto <D.42253>;
    <D.42252>:
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    D.42221->next = inst;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    inst->prev = D.42221;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    goto <D.42254>;
    <D.42253>:
    D.42220 = cfg->cbb;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    D.42221 = D.42220->last_ins;
    D.42220->code = D.42221;
    <D.42254>:
  }
  {
    struct MonoInst * inst;

    D.42214 = cfg->mempool;
    inst = mono_mempool_alloc (D.42214, 80);
    inst->data.op[1].const_val = 0;
    D.42255 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42255;
    inst->prev = 0B;
    D.42256 = inst->prev;
    inst->next = D.42256;
    inst->opcode = 393;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42257 = inst->sreg3;
    inst->sreg2 = D.42257;
    D.42258 = inst->sreg2;
    inst->sreg1 = D.42258;
    D.42219 = cfg->ip;
    inst->cil_code = D.42219;
    inst->dreg = high1_reg;
    inst->sreg1 = bounds_reg;
    inst->data.op[0].const_val = 0;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    if (D.42221 != 0B) goto <D.42259>; else goto <D.42260>;
    <D.42259>:
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    D.42221->next = inst;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    inst->prev = D.42221;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    goto <D.42261>;
    <D.42260>:
    D.42220 = cfg->cbb;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    D.42221 = D.42220->last_ins;
    D.42220->code = D.42221;
    <D.42261>:
  }
  {
    struct MonoInst * inst;

    D.42214 = cfg->mempool;
    inst = mono_mempool_alloc (D.42214, 80);
    inst->data.op[1].const_val = 0;
    D.42262 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42262;
    inst->prev = 0B;
    D.42263 = inst->prev;
    inst->next = D.42263;
    inst->opcode = 322;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42264 = inst->sreg3;
    inst->sreg2 = D.42264;
    D.42265 = inst->sreg2;
    inst->sreg1 = D.42265;
    D.42219 = cfg->ip;
    inst->cil_code = D.42219;
    inst->dreg = -1;
    inst->sreg1 = high1_reg;
    inst->sreg2 = realidx1_reg;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    if (D.42221 != 0B) goto <D.42266>; else goto <D.42267>;
    <D.42266>:
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    D.42221->next = inst;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    inst->prev = D.42221;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    goto <D.42268>;
    <D.42267>:
    D.42220 = cfg->cbb;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    D.42221 = D.42220->last_ins;
    D.42220->code = D.42221;
    <D.42268>:
  }
  {
    struct MonoInst * inst;

    D.42214 = cfg->mempool;
    inst = mono_mempool_alloc (D.42214, 80);
    inst->data.op[1].const_val = 0;
    D.42269 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42269;
    inst->prev = 0B;
    D.42270 = inst->prev;
    inst->next = D.42270;
    inst->opcode = 459;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42271 = inst->sreg3;
    inst->sreg2 = D.42271;
    D.42272 = inst->sreg2;
    inst->sreg1 = D.42272;
    D.42219 = cfg->ip;
    inst->cil_code = D.42219;
    inst->data.op[1].p = "IndexOutOfRangeException";
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    if (D.42221 != 0B) goto <D.42273>; else goto <D.42274>;
    <D.42273>:
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    D.42221->next = inst;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    inst->prev = D.42221;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    goto <D.42275>;
    <D.42274>:
    D.42220 = cfg->cbb;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    D.42221 = D.42220->last_ins;
    D.42220->code = D.42221;
    <D.42275>:
  }
  {
    struct MonoInst * inst;

    D.42214 = cfg->mempool;
    inst = mono_mempool_alloc (D.42214, 80);
    inst->data.op[1].const_val = 0;
    D.42276 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42276;
    inst->prev = 0B;
    D.42277 = inst->prev;
    inst->next = D.42277;
    inst->opcode = 393;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42278 = inst->sreg3;
    inst->sreg2 = D.42278;
    D.42279 = inst->sreg2;
    inst->sreg1 = D.42279;
    D.42219 = cfg->ip;
    inst->cil_code = D.42219;
    inst->dreg = low2_reg;
    inst->sreg1 = bounds_reg;
    inst->data.op[0].const_val = 12;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    if (D.42221 != 0B) goto <D.42280>; else goto <D.42281>;
    <D.42280>:
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    D.42221->next = inst;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    inst->prev = D.42221;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    goto <D.42282>;
    <D.42281>:
    D.42220 = cfg->cbb;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    D.42221 = D.42220->last_ins;
    D.42220->code = D.42221;
    <D.42282>:
  }
  {
    struct MonoInst * inst;

    D.42214 = cfg->mempool;
    inst = mono_mempool_alloc (D.42214, 80);
    inst->data.op[1].const_val = 0;
    D.42283 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42283;
    inst->prev = 0B;
    D.42284 = inst->prev;
    inst->next = D.42284;
    inst->opcode = 480;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42285 = inst->sreg3;
    inst->sreg2 = D.42285;
    D.42286 = inst->sreg2;
    inst->sreg1 = D.42286;
    D.42219 = cfg->ip;
    inst->cil_code = D.42219;
    inst->dreg = realidx2_reg;
    inst->sreg1 = index2;
    inst->sreg2 = low2_reg;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    if (D.42221 != 0B) goto <D.42287>; else goto <D.42288>;
    <D.42287>:
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    D.42221->next = inst;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    inst->prev = D.42221;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    goto <D.42289>;
    <D.42288>:
    D.42220 = cfg->cbb;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    D.42221 = D.42220->last_ins;
    D.42220->code = D.42221;
    <D.42289>:
  }
  {
    struct MonoInst * inst;

    D.42214 = cfg->mempool;
    inst = mono_mempool_alloc (D.42214, 80);
    inst->data.op[1].const_val = 0;
    D.42290 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42290;
    inst->prev = 0B;
    D.42291 = inst->prev;
    inst->next = D.42291;
    inst->opcode = 393;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42292 = inst->sreg3;
    inst->sreg2 = D.42292;
    D.42293 = inst->sreg2;
    inst->sreg1 = D.42293;
    D.42219 = cfg->ip;
    inst->cil_code = D.42219;
    inst->dreg = high2_reg;
    inst->sreg1 = bounds_reg;
    inst->data.op[0].const_val = 8;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    if (D.42221 != 0B) goto <D.42294>; else goto <D.42295>;
    <D.42294>:
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    D.42221->next = inst;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    inst->prev = D.42221;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    goto <D.42296>;
    <D.42295>:
    D.42220 = cfg->cbb;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    D.42221 = D.42220->last_ins;
    D.42220->code = D.42221;
    <D.42296>:
  }
  {
    struct MonoInst * inst;

    D.42214 = cfg->mempool;
    inst = mono_mempool_alloc (D.42214, 80);
    inst->data.op[1].const_val = 0;
    D.42297 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42297;
    inst->prev = 0B;
    D.42298 = inst->prev;
    inst->next = D.42298;
    inst->opcode = 322;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42299 = inst->sreg3;
    inst->sreg2 = D.42299;
    D.42300 = inst->sreg2;
    inst->sreg1 = D.42300;
    D.42219 = cfg->ip;
    inst->cil_code = D.42219;
    inst->dreg = -1;
    inst->sreg1 = high2_reg;
    inst->sreg2 = realidx2_reg;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    if (D.42221 != 0B) goto <D.42301>; else goto <D.42302>;
    <D.42301>:
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    D.42221->next = inst;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    inst->prev = D.42221;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    goto <D.42303>;
    <D.42302>:
    D.42220 = cfg->cbb;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    D.42221 = D.42220->last_ins;
    D.42220->code = D.42221;
    <D.42303>:
  }
  {
    struct MonoInst * inst;

    D.42214 = cfg->mempool;
    inst = mono_mempool_alloc (D.42214, 80);
    inst->data.op[1].const_val = 0;
    D.42304 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42304;
    inst->prev = 0B;
    D.42305 = inst->prev;
    inst->next = D.42305;
    inst->opcode = 459;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42306 = inst->sreg3;
    inst->sreg2 = D.42306;
    D.42307 = inst->sreg2;
    inst->sreg1 = D.42307;
    D.42219 = cfg->ip;
    inst->cil_code = D.42219;
    inst->data.op[1].p = "IndexOutOfRangeException";
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    if (D.42221 != 0B) goto <D.42308>; else goto <D.42309>;
    <D.42308>:
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    D.42221->next = inst;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    inst->prev = D.42221;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    goto <D.42310>;
    <D.42309>:
    D.42220 = cfg->cbb;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    D.42221 = D.42220->last_ins;
    D.42220->code = D.42221;
    <D.42310>:
  }
  {
    struct MonoInst * inst;

    D.42214 = cfg->mempool;
    inst = mono_mempool_alloc (D.42214, 80);
    inst->data.op[1].const_val = 0;
    D.42311 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42311;
    inst->prev = 0B;
    D.42312 = inst->prev;
    inst->next = D.42312;
    inst->opcode = 481;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42313 = inst->sreg3;
    inst->sreg2 = D.42313;
    D.42314 = inst->sreg2;
    inst->sreg1 = D.42314;
    D.42219 = cfg->ip;
    inst->cil_code = D.42219;
    inst->dreg = mult_reg;
    inst->sreg1 = high2_reg;
    inst->sreg2 = realidx1_reg;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    if (D.42221 != 0B) goto <D.42315>; else goto <D.42316>;
    <D.42315>:
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    D.42221->next = inst;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    inst->prev = D.42221;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    goto <D.42317>;
    <D.42316>:
    D.42220 = cfg->cbb;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    D.42221 = D.42220->last_ins;
    D.42220->code = D.42221;
    <D.42317>:
  }
  {
    struct MonoInst * inst;

    D.42214 = cfg->mempool;
    inst = mono_mempool_alloc (D.42214, 80);
    inst->data.op[1].const_val = 0;
    D.42318 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42318;
    inst->prev = 0B;
    D.42319 = inst->prev;
    inst->next = D.42319;
    inst->opcode = 479;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42320 = inst->sreg3;
    inst->sreg2 = D.42320;
    D.42321 = inst->sreg2;
    inst->sreg1 = D.42321;
    D.42219 = cfg->ip;
    inst->cil_code = D.42219;
    inst->dreg = sum_reg;
    inst->sreg1 = mult_reg;
    inst->sreg2 = realidx2_reg;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    if (D.42221 != 0B) goto <D.42322>; else goto <D.42323>;
    <D.42322>:
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    D.42221->next = inst;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    inst->prev = D.42221;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    goto <D.42324>;
    <D.42323>:
    D.42220 = cfg->cbb;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    D.42221 = D.42220->last_ins;
    D.42220->code = D.42221;
    <D.42324>:
  }
  {
    struct MonoInst * inst;

    D.42214 = cfg->mempool;
    inst = mono_mempool_alloc (D.42214, 80);
    inst->data.op[1].const_val = 0;
    D.42325 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42325;
    inst->prev = 0B;
    D.42326 = inst->prev;
    inst->next = D.42326;
    inst->opcode = 540;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42327 = inst->sreg3;
    inst->sreg2 = D.42327;
    D.42328 = inst->sreg2;
    inst->sreg1 = D.42328;
    D.42219 = cfg->ip;
    inst->cil_code = D.42219;
    inst->dreg = mult2_reg;
    inst->sreg1 = sum_reg;
    D.42329 = (long int) size;
    inst->data.op[1].const_val = D.42329;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    if (D.42221 != 0B) goto <D.42330>; else goto <D.42331>;
    <D.42330>:
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    D.42221->next = inst;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    inst->prev = D.42221;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    goto <D.42332>;
    <D.42331>:
    D.42220 = cfg->cbb;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    D.42221 = D.42220->last_ins;
    D.42220->code = D.42221;
    <D.42332>:
  }
  {
    struct MonoInst * inst;

    D.42214 = cfg->mempool;
    inst = mono_mempool_alloc (D.42214, 80);
    inst->data.op[1].const_val = 0;
    D.42333 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42333;
    inst->prev = 0B;
    D.42334 = inst->prev;
    inst->next = D.42334;
    inst->opcode = 479;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42335 = inst->sreg3;
    inst->sreg2 = D.42335;
    D.42336 = inst->sreg2;
    inst->sreg1 = D.42336;
    D.42219 = cfg->ip;
    inst->cil_code = D.42219;
    inst->dreg = add_reg;
    inst->sreg1 = mult2_reg;
    D.42237 = arr->dreg;
    inst->sreg2 = D.42237;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    if (D.42221 != 0B) goto <D.42337>; else goto <D.42338>;
    <D.42337>:
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    D.42221->next = inst;
    D.42220 = cfg->cbb;
    D.42221 = D.42220->last_ins;
    inst->prev = D.42221;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    goto <D.42339>;
    <D.42338>:
    D.42220 = cfg->cbb;
    D.42220 = cfg->cbb;
    D.42220->last_ins = inst;
    D.42221 = D.42220->last_ins;
    D.42220->code = D.42221;
    <D.42339>:
  }
  D.42214 = cfg->mempool;
  ins = mono_mempool_alloc (D.42214, 80);
  ins->data.op[1].const_val = 0;
  D.42340 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.42340;
  ins->prev = 0B;
  D.42341 = ins->prev;
  ins->next = D.42341;
  ins->opcode = 538;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.42342 = ins->sreg3;
  ins->sreg2 = D.42342;
  D.42343 = ins->sreg2;
  ins->sreg1 = D.42343;
  D.42219 = cfg->ip;
  ins->cil_code = D.42219;
  ins->dreg = add_reg;
  ins->sreg1 = add_reg;
  ins->data.op[1].const_val = 32;
  ins->type = 5;
  ins->klass = klass;
  D.42220 = cfg->cbb;
  D.42221 = D.42220->last_ins;
  if (D.42221 != 0B) goto <D.42344>; else goto <D.42345>;
  <D.42344>:
  D.42220 = cfg->cbb;
  D.42221 = D.42220->last_ins;
  D.42221->next = ins;
  D.42220 = cfg->cbb;
  D.42221 = D.42220->last_ins;
  ins->prev = D.42221;
  D.42220 = cfg->cbb;
  D.42220->last_ins = ins;
  goto <D.42346>;
  <D.42345>:
  D.42220 = cfg->cbb;
  D.42220 = cfg->cbb;
  D.42220->last_ins = ins;
  D.42221 = D.42220->last_ins;
  D.42220->code = D.42221;
  <D.42346>:
  D.42347 = ins;
  return D.42347;
}


mini_redirect_call (struct MonoCompile * cfg, struct MonoMethod * method, struct MonoMethodSignature * signature, struct MonoInst * * args, struct MonoInst * this)
{
  struct MonoClass * D.42349;
  struct MonoClass * D.42350;
  const char * D.42353;
  int D.42354;
  <unnamed type> mono_profiler_events.350;
  unsigned int D.42358;
  unsigned int D.42361;
  unsigned int D.42362;
  struct MonoDomain * D.42365;
  _Bool D.42366;
  long int D.42367;
  long int D.42368;
  struct MonoInst * D.42373;
  struct MonoMemPool * D.42374;
  void * D.42375;
  struct MonoInst * D.42376;
  long int D.42377;
  struct MonoInst * D.42378;
  guint16 iftmp.351;
  long unsigned int D.42380;
  long unsigned int D.42381;
  int D.42385;
  int D.42386;
  const unsigned char * D.42387;
  void * iftmp.352;
  unsigned int D.42392;
  int D.42393;
  struct MonoBasicBlock * D.42394;
  struct MonoInst * D.42395;
  struct MonoInst * D.42399;

  D.42349 = method->klass;
  D.42350 = mono_defaults.string_class;
  if (D.42349 == D.42350) goto <D.42351>; else goto <D.42352>;
  <D.42351>:
  D.42353 = method->name;
  D.42354 = strcmp (D.42353, "InternalAllocateStr");
  if (D.42354 == 0) goto <D.42355>; else goto <D.42356>;
  <D.42355>:
  mono_profiler_events.350 = mono_profiler_events;
  D.42358 = mono_profiler_events.350 & 128;
  if (D.42358 == 0) goto <D.42359>; else goto <D.42360>;
  <D.42359>:
  D.42361 = cfg->opt;
  D.42362 = D.42361 & 512;
  if (D.42362 == 0) goto <D.42363>; else goto <D.42364>;
  <D.42363>:
  {
    struct MonoInst * iargs[2];
    struct MonoVTable * vtable;
    struct MonoMethod * managed_alloc;

    try
      {
        D.42365 = cfg->domain;
        D.42349 = method->klass;
        vtable = mono_class_vtable (D.42365, D.42349);
        managed_alloc = 0B;
        D.42366 = vtable == 0B;
        D.42367 = (long int) D.42366;
        D.42368 = __builtin_expect (D.42367, 0);
        if (D.42368 != 0) goto <D.42369>; else goto <D.42370>;
        <D.42369>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 5598, "vtable");
        <D.42370>:
        D.42349 = method->klass;
        managed_alloc = mono_gc_get_managed_allocator (D.42349, 0);
        if (managed_alloc == 0B) goto <D.42371>; else goto <D.42372>;
        <D.42371>:
        D.42373 = 0B;
        return D.42373;
        <D.42372>:
        D.42374 = cfg->mempool;
        D.42375 = mono_mempool_alloc (D.42374, 80);
        iargs[0] = D.42375;
        D.42376 = iargs[0];
        D.42376 = iargs[0];
        D.42376->data.op[1].const_val = 0;
        D.42377 = D.42376->data.op[1].const_val;
        D.42376->data.op[0].const_val = D.42377;
        D.42376 = iargs[0];
        D.42376 = iargs[0];
        D.42376->prev = 0B;
        D.42378 = D.42376->prev;
        D.42376->next = D.42378;
        D.42376 = iargs[0];
        D.42380 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.42381 = D.42380 & 33554432;
        if (D.42381 != 0) goto <D.42382>; else goto <D.42383>;
        <D.42382>:
        iftmp.351 = 732;
        goto <D.42384>;
        <D.42383>:
        iftmp.351 = 363;
        <D.42384>:
        D.42376->opcode = iftmp.351;
        D.42376 = iargs[0];
        D.42376->flags = 0;
        D.42376 = iargs[0];
        D.42376->type = 0;
        D.42376 = iargs[0];
        D.42376->dreg = -1;
        D.42376 = iargs[0];
        D.42376 = iargs[0];
        D.42376 = iargs[0];
        D.42376->sreg3 = -1;
        D.42385 = D.42376->sreg3;
        D.42376->sreg2 = D.42385;
        D.42386 = D.42376->sreg2;
        D.42376->sreg1 = D.42386;
        D.42376 = iargs[0];
        D.42387 = cfg->ip;
        D.42376->cil_code = D.42387;
        D.42376 = iargs[0];
        D.42380 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.42381 = D.42380 & 33554432;
        if (D.42381 != 0) goto <D.42389>; else goto <D.42390>;
        <D.42389>:
        iftmp.352 = vtable->klass;
        goto <D.42391>;
        <D.42390>:
        iftmp.352 = vtable;
        <D.42391>:
        D.42376->data.op[0].p = iftmp.352;
        D.42376 = iargs[0];
        D.42376->data.op[1].src = 14B;
        D.42376 = iargs[0];
        D.42376->type = 3;
        D.42376 = iargs[0];
        D.42392 = alloc_dreg (cfg, 3);
        D.42393 = (int) D.42392;
        D.42376->dreg = D.42393;
        D.42394 = cfg->cbb;
        D.42395 = D.42394->last_ins;
        if (D.42395 != 0B) goto <D.42396>; else goto <D.42397>;
        <D.42396>:
        D.42394 = cfg->cbb;
        D.42395 = D.42394->last_ins;
        D.42376 = iargs[0];
        D.42395->next = D.42376;
        D.42376 = iargs[0];
        D.42394 = cfg->cbb;
        D.42395 = D.42394->last_ins;
        D.42376->prev = D.42395;
        D.42394 = cfg->cbb;
        D.42376 = iargs[0];
        D.42394->last_ins = D.42376;
        goto <D.42398>;
        <D.42397>:
        D.42394 = cfg->cbb;
        D.42394 = cfg->cbb;
        D.42376 = iargs[0];
        D.42394->last_ins = D.42376;
        D.42395 = D.42394->last_ins;
        D.42394->code = D.42395;
        <D.42398>:
        D.42399 = *args;
        iargs[1] = D.42399;
        D.42373 = mono_emit_method_call (cfg, managed_alloc, &iargs, this);
        return D.42373;
      }
    finally
      {
        iargs = {CLOBBER};
      }
  }
  <D.42364>:
  <D.42360>:
  <D.42356>:
  <D.42352>:
  D.42373 = 0B;
  return D.42373;
}


is_supported_tail_call (struct MonoCompile * cfg, struct MonoMethod * method, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, int call_opcode)
{
  int iftmp.353;
  struct MonoMethodSignature * D.42405;
  struct MonoMethodSignature * D.42406;
  int D.42407;
  struct MonoMethodSignature * D.42409;
  struct MonoType * D.42410;
  int D.42411;
  struct MonoType * D.42415;
  long unsigned int D.42416;
  long unsigned int D.42417;
  unsigned char D.42419;
  short unsigned int D.42421;
  int D.42422;
  long unsigned int D.42423;
  long unsigned int D.42424;
  struct MonoClass * D.42427;
  long unsigned int D.42428;
  long unsigned int D.42429;
  short unsigned int D.42432;
  int D.42433;
  int D.42434;
  struct MonoMethod * D.42437;
  long unsigned int D.42438;
  long unsigned int D.42439;
  long unsigned int D.42442;
  long unsigned int D.42443;
  gboolean D.42450;
  gboolean supported_tail_call;
  int i;

  D.42405 = mono_method_signature (method);
  D.42406 = mono_method_signature (cmethod);
  D.42407 = mono_metadata_signature_equal (D.42405, D.42406);
  if (D.42407 != 0) goto <D.42408>; else goto <D.42403>;
  <D.42408>:
  D.42409 = mono_method_signature (cmethod);
  D.42410 = D.42409->ret;
  D.42411 = mono_type_is_struct (D.42410);
  if (D.42411 == 0) goto <D.42412>; else goto <D.42403>;
  <D.42412>:
  iftmp.353 = 1;
  goto <D.42404>;
  <D.42403>:
  iftmp.353 = 0;
  <D.42404>:
  supported_tail_call = iftmp.353;
  i = 0;
  goto <D.27237>;
  <D.27236>:
  D.42415 = fsig->params[i];
  D.42416 = BIT_FIELD_REF <*D.42415, 64, 64>;
  D.42417 = D.42416 & 8589934592;
  if (D.42417 != 0) goto <D.42413>; else goto <D.42418>;
  <D.42418>:
  D.42415 = fsig->params[i];
  D.42419 = D.42415->type;
  if (D.42419 == 15) goto <D.42413>; else goto <D.42420>;
  <D.42420>:
  D.42415 = fsig->params[i];
  D.42419 = D.42415->type;
  if (D.42419 == 27) goto <D.42413>; else goto <D.42414>;
  <D.42413>:
  supported_tail_call = 0;
  <D.42414>:
  i = i + 1;
  <D.27237>:
  D.42421 = fsig->param_count;
  D.42422 = (int) D.42421;
  if (D.42422 > i) goto <D.27236>; else goto <D.27238>;
  <D.27238>:
  D.42423 = BIT_FIELD_REF <*fsig, 64, 64>;
  D.42424 = D.42423 & 512;
  if (D.42424 != 0) goto <D.42425>; else goto <D.42426>;
  <D.42425>:
  D.42427 = cmethod->klass;
  D.42428 = BIT_FIELD_REF <*D.42427, 64, 256>;
  D.42429 = D.42428 & 1152921504606846976;
  if (D.42429 != 0) goto <D.42430>; else goto <D.42431>;
  <D.42430>:
  supported_tail_call = 0;
  <D.42431>:
  <D.42426>:
  D.42432 = cmethod->flags;
  D.42433 = (int) D.42432;
  D.42434 = D.42433 & 8192;
  if (D.42434 != 0) goto <D.42435>; else goto <D.42436>;
  <D.42435>:
  supported_tail_call = 0;
  <D.42436>:
  D.42437 = cfg->method;
  D.42438 = BIT_FIELD_REF <*D.42437, 64, 256>;
  D.42439 = D.42438 & 36028797018963968;
  if (D.42439 != 0) goto <D.42440>; else goto <D.42441>;
  <D.42440>:
  supported_tail_call = 0;
  <D.42441>:
  D.42442 = BIT_FIELD_REF <*cmethod, 64, 256>;
  D.42443 = D.42442 & 4467570830351532032;
  if (D.42443 != 0) goto <D.42444>; else goto <D.42445>;
  <D.42444>:
  D.42442 = BIT_FIELD_REF <*cmethod, 64, 256>;
  D.42443 = D.42442 & 4467570830351532032;
  if (D.42443 != 2449958197289549824) goto <D.42446>; else goto <D.42447>;
  <D.42446>:
  supported_tail_call = 0;
  <D.42447>:
  <D.42445>:
  if (call_opcode != 40) goto <D.42448>; else goto <D.42449>;
  <D.42448>:
  supported_tail_call = 0;
  <D.42449>:
  D.42450 = supported_tail_call;
  return D.42450;
}


mono_emit_widen_call_res (struct MonoCompile * cfg, struct MonoInst * ins, struct MonoMethodSignature * fsig)
{
  struct MonoType * D.42452;
  int D.42453;
  long unsigned int D.42456;
  long unsigned int D.42457;
  long unsigned int D.42460;
  long unsigned int D.42461;
  unsigned int D.42464;
  unsigned int D.42467;
  struct MonoMemPool * D.42468;
  long int D.42469;
  struct MonoInst * D.42470;
  short unsigned int D.42471;
  int D.42472;
  int D.42473;
  const unsigned char * D.42474;
  int D.42475;
  struct MonoBasicBlock * D.42476;
  struct MonoInst * D.42477;
  unsigned char D.42481;
  struct MonoInst * D.42482;

  D.42452 = fsig->ret;
  D.42453 = mono_type_is_void (D.42452);
  if (D.42453 == 0) goto <D.42454>; else goto <D.42455>;
  <D.42454>:
  D.42456 = BIT_FIELD_REF <*fsig, 64, 64>;
  D.42457 = D.42456 & 128;
  if (D.42457 != 0) goto <D.42458>; else goto <D.42459>;
  <D.42458>:
  D.42452 = fsig->ret;
  D.42460 = BIT_FIELD_REF <*D.42452, 64, 64>;
  D.42461 = D.42460 & 8589934592;
  if (D.42461 == 0) goto <D.42462>; else goto <D.42463>;
  <D.42462>:
  {
    int widen_op;

    widen_op = -1;
    D.42452 = fsig->ret;
    D.42464 = mono_type_to_load_membase (cfg, D.42452);
    switch (D.42464) <default: <D.25994>, case 389: <D.25989>, case 390: <D.25991>, case 391: <D.25992>, case 392: <D.25993>>
    <D.25989>:
    widen_op = 580;
    goto <D.25990>;
    <D.25991>:
    widen_op = 591;
    goto <D.25990>;
    <D.25992>:
    widen_op = 581;
    goto <D.25990>;
    <D.25993>:
    widen_op = 590;
    goto <D.25990>;
    <D.25994>:
    goto <D.25990>;
    <D.25990>:
    if (widen_op != -1) goto <D.42465>; else goto <D.42466>;
    <D.42465>:
    {
      int dreg;
      struct MonoInst * widen;

      D.42467 = alloc_preg (cfg);
      dreg = (int) D.42467;
      D.42468 = cfg->mempool;
      widen = mono_mempool_alloc (D.42468, 80);
      widen->data.op[1].const_val = 0;
      D.42469 = widen->data.op[1].const_val;
      widen->data.op[0].const_val = D.42469;
      widen->prev = 0B;
      D.42470 = widen->prev;
      widen->next = D.42470;
      D.42471 = (short unsigned int) widen_op;
      widen->opcode = D.42471;
      widen->flags = 0;
      widen->type = 0;
      widen->dreg = -1;
      widen->sreg3 = -1;
      D.42472 = widen->sreg3;
      widen->sreg2 = D.42472;
      D.42473 = widen->sreg2;
      widen->sreg1 = D.42473;
      D.42474 = cfg->ip;
      widen->cil_code = D.42474;
      widen->dreg = dreg;
      D.42475 = ins->dreg;
      widen->sreg1 = D.42475;
      D.42476 = cfg->cbb;
      D.42477 = D.42476->last_ins;
      if (D.42477 != 0B) goto <D.42478>; else goto <D.42479>;
      <D.42478>:
      D.42476 = cfg->cbb;
      D.42477 = D.42476->last_ins;
      D.42477->next = widen;
      D.42476 = cfg->cbb;
      D.42477 = D.42476->last_ins;
      widen->prev = D.42477;
      D.42476 = cfg->cbb;
      D.42476->last_ins = widen;
      goto <D.42480>;
      <D.42479>:
      D.42476 = cfg->cbb;
      D.42476 = cfg->cbb;
      D.42476->last_ins = widen;
      D.42477 = D.42476->last_ins;
      D.42476->code = D.42477;
      <D.42480>:
      D.42481 = ins->type;
      widen->type = D.42481;
      ins = widen;
    }
    <D.42466>:
  }
  <D.42463>:
  <D.42459>:
  <D.42455>:
  D.42482 = ins;
  return D.42482;
}


emit_pop_lmf (struct MonoCompile * cfg)
{
  long unsigned int D.42485;
  long unsigned int D.42486;
  struct MonoMemPool * D.42489;
  long int D.42490;
  struct MonoInst * D.42491;
  int D.42492;
  int D.42493;
  const unsigned char * D.42494;
  struct MonoInst * D.42495;
  unsigned char D.42496;
  unsigned char D.42497;
  struct MonoClass * D.42498;
  unsigned int D.42499;
  int D.42500;
  int D.42501;
  _Bool D.42502;
  long int D.42503;
  long int D.42504;
  struct MonoType * D.42507;
  int D.42508;
  struct MonoInst * iftmp.354;
  int D.42514;
  int D.42515;
  unsigned int D.42516;
  unsigned int D.42517;
  struct MonoInst * * D.42520;
  sizetype D.42521;
  sizetype D.42522;
  sizetype D.42523;
  struct MonoInst * * D.42524;
  struct MonoInst * iftmp.355;
  int D.42527;
  unsigned int D.42528;
  sizetype D.42531;
  sizetype D.42532;
  struct MonoInst * * D.42533;
  _Bool D.42535;
  long int D.42536;
  long int D.42537;
  _Bool D.42540;
  long int D.42541;
  long int D.42542;
  unsigned char D.42545;
  unsigned char D.42546;
  unsigned char D.42547;
  unsigned char D.42548;
  struct MonoBasicBlock * D.42549;
  struct MonoInst * D.42550;
  long unsigned int D.42556;
  int D.42558;
  unsigned int D.42560;
  struct MonoInst * D.42564;
  struct MonoClass * D.42567;
  struct MonoType * D.42568;
  struct MonoInst * D.42569;
  unsigned int D.42570;
  int lmf_reg;
  int lmf_addr_reg;
  int prev_lmf_reg;
  struct MonoInst * ins;

  D.42485 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.42486 = D.42485 & 32;
  if (D.42486 == 0) goto <D.42487>; else goto <D.42488>;
  <D.42487>:
  return;
  <D.42488>:
  D.42489 = cfg->mempool;
  ins = mono_mempool_alloc (D.42489, 80);
  ins->data.op[1].const_val = 0;
  D.42490 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.42490;
  ins->prev = 0B;
  D.42491 = ins->prev;
  ins->next = D.42491;
  ins->opcode = 314;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.42492 = ins->sreg3;
  ins->sreg2 = D.42492;
  D.42493 = ins->sreg2;
  ins->sreg1 = D.42493;
  D.42494 = cfg->ip;
  ins->cil_code = D.42494;
  D.42495 = cfg->lmf_var;
  ins->data.op[0].p = D.42495;
  D.42495 = cfg->lmf_var;
  D.42495 = cfg->lmf_var;
  D.42496 = D.42495->flags;
  D.42497 = D.42496 | 16;
  D.42495->flags = D.42497;
  ins->type = 5;
  D.42495 = cfg->lmf_var;
  D.42498 = D.42495->klass;
  ins->klass = D.42498;
  D.42499 = alloc_dreg (cfg, 5);
  D.42500 = (int) D.42499;
  ins->dreg = D.42500;
  cfg->has_indirection = 1;
  D.42501 = cfg->gsharedvt;
  D.42502 = D.42501 != 0;
  D.42503 = (long int) D.42502;
  D.42504 = __builtin_expect (D.42503, 0);
  if (D.42504 != 0) goto <D.42505>; else goto <D.42506>;
  <D.42505>:
  D.42495 = cfg->lmf_var;
  D.42507 = D.42495->data.op[1].vtype;
  D.42508 = mini_is_gsharedvt_variable_type (cfg, D.42507);
  if (D.42508 != 0) goto <D.42509>; else goto <D.42510>;
  <D.42509>:
  handle_gsharedvt_ldaddr (cfg);
  <D.42510>:
  <D.42506>:
  if (0 != 0) goto <D.42511>; else goto <D.42512>;
  <D.42511>:
  {
    struct MonoInst * var1;
    struct MonoInst * var2;

    D.42495 = cfg->lmf_var;
    D.42514 = D.42495->dreg;
    D.42515 = D.42514 + 1;
    D.42516 = (unsigned int) D.42515;
    D.42517 = cfg->vreg_to_inst_len;
    if (D.42516 < D.42517) goto <D.42518>; else goto <D.42519>;
    <D.42518>:
    D.42520 = cfg->vreg_to_inst;
    D.42495 = cfg->lmf_var;
    D.42514 = D.42495->dreg;
    D.42521 = (sizetype) D.42514;
    D.42522 = D.42521 + 1;
    D.42523 = D.42522 * 8;
    D.42524 = D.42520 + D.42523;
    iftmp.354 = *D.42524;
    goto <D.42525>;
    <D.42519>:
    iftmp.354 = 0B;
    <D.42525>:
    var1 = iftmp.354;
    D.42495 = cfg->lmf_var;
    D.42514 = D.42495->dreg;
    D.42527 = D.42514 + 2;
    D.42528 = (unsigned int) D.42527;
    D.42517 = cfg->vreg_to_inst_len;
    if (D.42528 < D.42517) goto <D.42529>; else goto <D.42530>;
    <D.42529>:
    D.42520 = cfg->vreg_to_inst;
    D.42495 = cfg->lmf_var;
    D.42514 = D.42495->dreg;
    D.42521 = (sizetype) D.42514;
    D.42531 = D.42521 + 2;
    D.42532 = D.42531 * 8;
    D.42533 = D.42520 + D.42532;
    iftmp.355 = *D.42533;
    goto <D.42534>;
    <D.42530>:
    iftmp.355 = 0B;
    <D.42534>:
    var2 = iftmp.355;
    D.42535 = var1 == 0B;
    D.42536 = (long int) D.42535;
    D.42537 = __builtin_expect (D.42536, 0);
    if (D.42537 != 0) goto <D.42538>; else goto <D.42539>;
    <D.42538>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1970, "var1");
    <D.42539>:
    D.42540 = var2 == 0B;
    D.42541 = (long int) D.42540;
    D.42542 = __builtin_expect (D.42541, 0);
    if (D.42542 != 0) goto <D.42543>; else goto <D.42544>;
    <D.42543>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1970, "var2");
    <D.42544>:
    D.42545 = var1->flags;
    D.42546 = D.42545 | 16;
    var1->flags = D.42546;
    D.42547 = var2->flags;
    D.42548 = D.42547 | 16;
    var2->flags = D.42548;
  }
  <D.42512>:
  D.42549 = cfg->cbb;
  D.42550 = D.42549->last_ins;
  if (D.42550 != 0B) goto <D.42551>; else goto <D.42552>;
  <D.42551>:
  D.42549 = cfg->cbb;
  D.42550 = D.42549->last_ins;
  D.42550->next = ins;
  D.42549 = cfg->cbb;
  D.42550 = D.42549->last_ins;
  ins->prev = D.42550;
  D.42549 = cfg->cbb;
  D.42549->last_ins = ins;
  goto <D.42553>;
  <D.42552>:
  D.42549 = cfg->cbb;
  D.42549 = cfg->cbb;
  D.42549->last_ins = ins;
  D.42550 = D.42549->last_ins;
  D.42549->code = D.42550;
  <D.42553>:
  lmf_reg = ins->dreg;
  D.42485 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.42556 = D.42485 & 16;
  if (D.42556 != 0) goto <D.42557>; else goto <D.42554>;
  <D.42557>:
  D.42558 = mini_tls_get_supported (cfg, 3);
  if (D.42558 != 0) goto <D.42559>; else goto <D.42554>;
  <D.42559>:
  D.42560 = alloc_preg (cfg);
  prev_lmf_reg = (int) D.42560;
  D.42489 = cfg->mempool;
  ins = mono_mempool_alloc (D.42489, 80);
  ins->data.op[1].const_val = 0;
  D.42490 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.42490;
  ins->prev = 0B;
  D.42491 = ins->prev;
  ins->next = D.42491;
  ins->opcode = 388;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.42492 = ins->sreg3;
  ins->sreg2 = D.42492;
  D.42493 = ins->sreg2;
  ins->sreg1 = D.42493;
  D.42494 = cfg->ip;
  ins->cil_code = D.42494;
  ins->dreg = prev_lmf_reg;
  ins->sreg1 = lmf_reg;
  ins->data.op[0].const_val = 0;
  ins->type = 1;
  D.42549 = cfg->cbb;
  D.42550 = D.42549->last_ins;
  if (D.42550 != 0B) goto <D.42561>; else goto <D.42562>;
  <D.42561>:
  D.42549 = cfg->cbb;
  D.42550 = D.42549->last_ins;
  D.42550->next = ins;
  D.42549 = cfg->cbb;
  D.42550 = D.42549->last_ins;
  ins->prev = D.42550;
  D.42549 = cfg->cbb;
  D.42549->last_ins = ins;
  goto <D.42563>;
  <D.42562>:
  D.42549 = cfg->cbb;
  D.42549 = cfg->cbb;
  D.42549->last_ins = ins;
  D.42550 = D.42549->last_ins;
  D.42549->code = D.42550;
  <D.42563>:
  emit_tls_set (cfg, prev_lmf_reg, 3);
  goto <D.42555>;
  <D.42554>:
  D.42564 = cfg->lmf_addr_var;
  if (D.42564 == 0B) goto <D.42565>; else goto <D.42566>;
  <D.42565>:
  D.42567 = mono_defaults.int_class;
  D.42568 = &D.42567->byval_arg;
  D.42569 = mono_compile_create_var (cfg, D.42568, 329);
  cfg->lmf_addr_var = D.42569;
  <D.42566>:
  D.42564 = cfg->lmf_addr_var;
  lmf_addr_reg = D.42564->dreg;
  D.42570 = alloc_preg (cfg);
  prev_lmf_reg = (int) D.42570;
  D.42489 = cfg->mempool;
  ins = mono_mempool_alloc (D.42489, 80);
  ins->data.op[1].const_val = 0;
  D.42490 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.42490;
  ins->prev = 0B;
  D.42491 = ins->prev;
  ins->next = D.42491;
  ins->opcode = 388;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.42492 = ins->sreg3;
  ins->sreg2 = D.42492;
  D.42493 = ins->sreg2;
  ins->sreg1 = D.42493;
  D.42494 = cfg->ip;
  ins->cil_code = D.42494;
  ins->dreg = prev_lmf_reg;
  ins->sreg1 = lmf_reg;
  ins->data.op[0].const_val = 0;
  ins->type = 1;
  D.42549 = cfg->cbb;
  D.42550 = D.42549->last_ins;
  if (D.42550 != 0B) goto <D.42571>; else goto <D.42572>;
  <D.42571>:
  D.42549 = cfg->cbb;
  D.42550 = D.42549->last_ins;
  D.42550->next = ins;
  D.42549 = cfg->cbb;
  D.42550 = D.42549->last_ins;
  ins->prev = D.42550;
  D.42549 = cfg->cbb;
  D.42549->last_ins = ins;
  goto <D.42573>;
  <D.42572>:
  D.42549 = cfg->cbb;
  D.42549 = cfg->cbb;
  D.42549->last_ins = ins;
  D.42550 = D.42549->last_ins;
  D.42549->code = D.42550;
  <D.42573>:
  D.42489 = cfg->mempool;
  ins = mono_mempool_alloc (D.42489, 80);
  ins->data.op[1].const_val = 0;
  D.42490 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.42490;
  ins->prev = 0B;
  D.42491 = ins->prev;
  ins->next = D.42491;
  ins->opcode = 374;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.42492 = ins->sreg3;
  ins->sreg2 = D.42492;
  D.42493 = ins->sreg2;
  ins->sreg1 = D.42493;
  D.42494 = cfg->ip;
  ins->cil_code = D.42494;
  ins->sreg1 = prev_lmf_reg;
  ins->dreg = lmf_addr_reg;
  ins->data.op[0].const_val = 0;
  D.42549 = cfg->cbb;
  D.42550 = D.42549->last_ins;
  if (D.42550 != 0B) goto <D.42574>; else goto <D.42575>;
  <D.42574>:
  D.42549 = cfg->cbb;
  D.42550 = D.42549->last_ins;
  D.42550->next = ins;
  D.42549 = cfg->cbb;
  D.42550 = D.42549->last_ins;
  ins->prev = D.42550;
  D.42549 = cfg->cbb;
  D.42549->last_ins = ins;
  goto <D.42576>;
  <D.42575>:
  D.42549 = cfg->cbb;
  D.42549 = cfg->cbb;
  D.42549->last_ins = ins;
  D.42550 = D.42549->last_ins;
  D.42549->code = D.42550;
  <D.42576>:
  <D.42555>:
}


emit_tls_set (struct MonoCompile * cfg, int sreg1, int tls_key)
{
  long unsigned int D.42578;
  long unsigned int D.42579;
  struct MonoMemPool * D.42584;
  long int D.42585;
  struct MonoInst * D.42586;
  guint16 iftmp.356;
  int D.42591;
  int D.42592;
  const unsigned char * D.42593;
  long int D.42594;
  void * D.42595;
  unsigned int D.42596;
  int D.42597;
  <unnamed type> tls_key.357;
  long int D.42600;
  void * D.42601;
  unsigned int D.42602;
  int D.42603;
  struct MonoBasicBlock * D.42604;
  struct MonoInst * D.42605;
  long int D.42609;
  struct MonoInst * D.42610;
  int D.42611;
  int D.42612;
  int D.42613;
  int D.42618;
  long int D.42619;
  struct MonoInst * ins;
  struct MonoInst * c;

  D.42578 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.42579 = D.42578 & 33554432;
  if (D.42579 != 0) goto <D.42580>; else goto <D.42581>;
  <D.42580>:
  D.42578 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.42579 = D.42578 & 33554432;
  if (D.42579 != 0) goto <D.42582>; else goto <D.42583>;
  <D.42582>:
  D.42584 = cfg->mempool;
  c = mono_mempool_alloc (D.42584, 80);
  c->data.op[1].const_val = 0;
  D.42585 = c->data.op[1].const_val;
  c->data.op[0].const_val = D.42585;
  c->prev = 0B;
  D.42586 = c->prev;
  c->next = D.42586;
  D.42578 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.42579 = D.42578 & 33554432;
  if (D.42579 != 0) goto <D.42588>; else goto <D.42589>;
  <D.42588>:
  iftmp.356 = 732;
  goto <D.42590>;
  <D.42589>:
  iftmp.356 = 363;
  <D.42590>:
  c->opcode = iftmp.356;
  c->flags = 0;
  c->type = 0;
  c->dreg = -1;
  c->sreg3 = -1;
  D.42591 = c->sreg3;
  c->sreg2 = D.42591;
  D.42592 = c->sreg2;
  c->sreg1 = D.42592;
  D.42593 = cfg->ip;
  c->cil_code = D.42593;
  D.42594 = (long int) tls_key;
  D.42595 = (void *) D.42594;
  c->data.op[0].p = D.42595;
  c->data.op[1].src = 48B;
  c->type = 3;
  D.42596 = alloc_dreg (cfg, 3);
  D.42597 = (int) D.42596;
  c->dreg = D.42597;
  goto <D.42598>;
  <D.42583>:
  {
    int _offset;

    tls_key.357 = (<unnamed type>) tls_key;
    _offset = mini_get_tls_offset (tls_key.357);
    D.42584 = cfg->mempool;
    c = mono_mempool_alloc (D.42584, 80);
    c->data.op[1].const_val = 0;
    D.42585 = c->data.op[1].const_val;
    c->data.op[0].const_val = D.42585;
    c->prev = 0B;
    D.42586 = c->prev;
    c->next = D.42586;
    c->opcode = 363;
    c->flags = 0;
    c->type = 0;
    c->dreg = -1;
    c->sreg3 = -1;
    D.42591 = c->sreg3;
    c->sreg2 = D.42591;
    D.42592 = c->sreg2;
    c->sreg1 = D.42592;
    D.42593 = cfg->ip;
    c->cil_code = D.42593;
    D.42600 = (long int) _offset;
    D.42601 = (void *) D.42600;
    c->data.op[0].p = D.42601;
    c->type = 3;
    D.42602 = alloc_dreg (cfg, 3);
    D.42603 = (int) D.42602;
    c->dreg = D.42603;
  }
  <D.42598>:
  D.42604 = cfg->cbb;
  D.42605 = D.42604->last_ins;
  if (D.42605 != 0B) goto <D.42606>; else goto <D.42607>;
  <D.42606>:
  D.42604 = cfg->cbb;
  D.42605 = D.42604->last_ins;
  D.42605->next = c;
  D.42604 = cfg->cbb;
  D.42605 = D.42604->last_ins;
  c->prev = D.42605;
  D.42604 = cfg->cbb;
  D.42604->last_ins = c;
  goto <D.42608>;
  <D.42607>:
  D.42604 = cfg->cbb;
  D.42604 = cfg->cbb;
  D.42604->last_ins = c;
  D.42605 = D.42604->last_ins;
  D.42604->code = D.42605;
  <D.42608>:
  D.42584 = cfg->mempool;
  ins = mono_mempool_alloc (D.42584, 80);
  ins->data.op[1].const_val = 0;
  D.42609 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.42609;
  ins->prev = 0B;
  D.42610 = ins->prev;
  ins->next = D.42610;
  ins->opcode = 794;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.42611 = ins->sreg3;
  ins->sreg2 = D.42611;
  D.42612 = ins->sreg2;
  ins->sreg1 = D.42612;
  D.42593 = cfg->ip;
  ins->cil_code = D.42593;
  ins->sreg1 = sreg1;
  D.42613 = c->dreg;
  ins->sreg2 = D.42613;
  D.42604 = cfg->cbb;
  D.42605 = D.42604->last_ins;
  if (D.42605 != 0B) goto <D.42614>; else goto <D.42615>;
  <D.42614>:
  D.42604 = cfg->cbb;
  D.42605 = D.42604->last_ins;
  D.42605->next = ins;
  D.42604 = cfg->cbb;
  D.42605 = D.42604->last_ins;
  ins->prev = D.42605;
  D.42604 = cfg->cbb;
  D.42604->last_ins = ins;
  goto <D.42616>;
  <D.42615>:
  D.42604 = cfg->cbb;
  D.42604 = cfg->cbb;
  D.42604->last_ins = ins;
  D.42605 = D.42604->last_ins;
  D.42604->code = D.42605;
  <D.42616>:
  goto <D.42617>;
  <D.42581>:
  D.42584 = cfg->mempool;
  ins = mono_mempool_alloc (D.42584, 80);
  ins->data.op[1].const_val = 0;
  D.42609 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.42609;
  ins->prev = 0B;
  D.42610 = ins->prev;
  ins->next = D.42610;
  ins->opcode = 793;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.42611 = ins->sreg3;
  ins->sreg2 = D.42611;
  D.42612 = ins->sreg2;
  ins->sreg1 = D.42612;
  D.42593 = cfg->ip;
  ins->cil_code = D.42593;
  ins->sreg1 = sreg1;
  tls_key.357 = (<unnamed type>) tls_key;
  D.42618 = mini_get_tls_offset (tls_key.357);
  D.42619 = (long int) D.42618;
  ins->data.op[0].const_val = D.42619;
  D.42604 = cfg->cbb;
  D.42605 = D.42604->last_ins;
  if (D.42605 != 0B) goto <D.42620>; else goto <D.42621>;
  <D.42620>:
  D.42604 = cfg->cbb;
  D.42605 = D.42604->last_ins;
  D.42605->next = ins;
  D.42604 = cfg->cbb;
  D.42605 = D.42604->last_ins;
  ins->prev = D.42605;
  D.42604 = cfg->cbb;
  D.42604->last_ins = ins;
  goto <D.42622>;
  <D.42621>:
  D.42604 = cfg->cbb;
  D.42604 = cfg->cbb;
  D.42604->last_ins = ins;
  D.42605 = D.42604->last_ins;
  D.42604->code = D.42605;
  <D.42622>:
  <D.42617>:
}


ldind_to_load_membase (int opcode)
{
  int D.42623;

  switch (opcode) <default: <D.28256>, case 70: <D.28245>, case 71: <D.28246>, case 72: <D.28247>, case 73: <D.28248>, case 74: <D.28249>, case 75: <D.28250>, case 76: <D.28253>, case 77: <D.28251>, case 78: <D.28254>, case 79: <D.28255>, case 80: <D.28252>>
  <D.28245>:
  D.42623 = 389;
  return D.42623;
  <D.28246>:
  D.42623 = 390;
  return D.42623;
  <D.28247>:
  D.42623 = 391;
  return D.42623;
  <D.28248>:
  D.42623 = 392;
  return D.42623;
  <D.28249>:
  D.42623 = 393;
  return D.42623;
  <D.28250>:
  D.42623 = 394;
  return D.42623;
  <D.28251>:
  D.42623 = 388;
  return D.42623;
  <D.28252>:
  D.42623 = 388;
  return D.42623;
  <D.28253>:
  D.42623 = 395;
  return D.42623;
  <D.28254>:
  D.42623 = 396;
  return D.42623;
  <D.28255>:
  D.42623 = 397;
  return D.42623;
  <D.28256>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 12163);
  D.42623 = -1;
  return D.42623;
}


stind_to_store_membase (int opcode)
{
  int D.42625;

  switch (opcode) <default: <D.28268>, case 81: <D.28264>, case 82: <D.28260>, case 83: <D.28261>, case 84: <D.28262>, case 85: <D.28265>, case 86: <D.28266>, case 87: <D.28267>, case 223: <D.28263>>
  <D.28260>:
  D.42625 = 375;
  return D.42625;
  <D.28261>:
  D.42625 = 376;
  return D.42625;
  <D.28262>:
  D.42625 = 377;
  return D.42625;
  <D.28263>:
  <D.28264>:
  D.42625 = 374;
  return D.42625;
  <D.28265>:
  D.42625 = 378;
  return D.42625;
  <D.28266>:
  D.42625 = 379;
  return D.42625;
  <D.28267>:
  D.42625 = 380;
  return D.42625;
  <D.28268>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 12189);
  D.42625 = -1;
  return D.42625;
}


is_exception_class (struct MonoClass * class)
{
  struct MonoClass * D.42627;
  gboolean D.42630;

  goto <D.27209>;
  <D.27208>:
  D.42627 = mono_defaults.exception_class;
  if (D.42627 == class) goto <D.42628>; else goto <D.42629>;
  <D.42628>:
  D.42630 = 1;
  return D.42630;
  <D.42629>:
  class = class->parent;
  <D.27209>:
  if (class != 0B) goto <D.27208>; else goto <D.27210>;
  <D.27210>:
  D.42630 = 0;
  return D.42630;
}


check_call_signature (struct MonoCompile * cfg, struct MonoMethodSignature * sig, struct MonoInst * * args)
{
  long unsigned int D.42632;
  long unsigned int D.42633;
  struct MonoInst * D.42636;
  unsigned char D.42637;
  unsigned char D.42638;
  int D.42643;
  struct MonoType * D.42644;
  long unsigned int D.42645;
  long unsigned int D.42646;
  long unsigned int D.42649;
  long unsigned int D.42650;
  struct MonoInst * * D.42651;
  struct MonoInst * D.42652;
  unsigned char D.42653;
  struct MonoGenericSharingContext * D.42658;
  unsigned char D.42659;
  int D.42660;
  struct MonoClass * D.42679;
  long unsigned int D.42680;
  long unsigned int D.42681;
  struct MonoGenericClass * D.42688;
  struct MonoClass * D.42689;
  short unsigned int D.42692;
  int D.42693;
  struct MonoType * simple_type;
  int i;
  void handle_enum = <<< error >>>;

  D.42632 = BIT_FIELD_REF <*sig, 64, 64>;
  D.42633 = D.42632 & 512;
  if (D.42633 != 0) goto <D.42634>; else goto <D.42635>;
  <D.42634>:
  D.42636 = *args;
  D.42637 = D.42636->type;
  D.42638 = D.42637 + 251;
  if (D.42638 > 1) goto <D.42639>; else goto <D.42640>;
  <D.42639>:
  D.42636 = *args;
  D.42637 = D.42636->type;
  if (D.42637 != 3) goto <D.42641>; else goto <D.42642>;
  <D.42641>:
  D.42643 = 1;
  return D.42643;
  <D.42642>:
  <D.42640>:
  args = args + 8;
  <D.42635>:
  i = 0;
  goto <D.25816>;
  <D.25815>:
  D.42644 = sig->params[i];
  D.42645 = BIT_FIELD_REF <*D.42644, 64, 64>;
  D.42646 = D.42645 & 8589934592;
  if (D.42646 != 0) goto <D.42647>; else goto <D.42648>;
  <D.42647>:
  D.42649 = (long unsigned int) i;
  D.42650 = D.42649 * 8;
  D.42651 = args + D.42650;
  D.42652 = *D.42651;
  D.42653 = D.42652->type;
  if (D.42653 != 5) goto <D.42654>; else goto <D.42655>;
  <D.42654>:
  D.42649 = (long unsigned int) i;
  D.42650 = D.42649 * 8;
  D.42651 = args + D.42650;
  D.42652 = *D.42651;
  D.42653 = D.42652->type;
  if (D.42653 != 3) goto <D.42656>; else goto <D.42657>;
  <D.42656>:
  D.42643 = 1;
  return D.42643;
  <D.42657>:
  <D.42655>:
  // predicted unlikely by continue predictor.
  goto <D.25784>;
  <D.42648>:
  simple_type = sig->params[i];
  D.42658 = cfg->generic_sharing_context;
  simple_type = mini_get_basic_type_from_generic (D.42658, simple_type);
  handle_enum:
  D.42659 = simple_type->type;
  D.42660 = (int) D.42659;
  switch (D.42660) <default: <D.25813>, case 1: <D.25786>, case 2: <D.25789>, case 3: <D.25792>, case 4: <D.25787>, case 5: <D.25788>, case 6: <D.25790>, case 7: <D.25791>, case 8: <D.25793>, case 9: <D.25794>, case 10: <D.25804>, case 11: <D.25805>, case 12: <D.25806>, case 13: <D.25807>, case 14: <D.25800>, case 15: <D.25797>, case 17: <D.25808>, case 18: <D.25799>, case 19: <D.25811>, case 20: <D.25803>, case 21: <D.25810>, case 22: <D.25809>, case 24: <D.25795>, case 25: <D.25796>, case 27: <D.25798>, case 28: <D.25801>, case 29: <D.25802>, case 30: <D.25812>>
  <D.25786>:
  D.42643 = 1;
  return D.42643;
  <D.25787>:
  <D.25788>:
  <D.25789>:
  <D.25790>:
  <D.25791>:
  <D.25792>:
  <D.25793>:
  <D.25794>:
  D.42649 = (long unsigned int) i;
  D.42650 = D.42649 * 8;
  D.42651 = args + D.42650;
  D.42652 = *D.42651;
  D.42653 = D.42652->type;
  if (D.42653 != 1) goto <D.42661>; else goto <D.42662>;
  <D.42661>:
  D.42649 = (long unsigned int) i;
  D.42650 = D.42649 * 8;
  D.42651 = args + D.42650;
  D.42652 = *D.42651;
  D.42653 = D.42652->type;
  if (D.42653 != 3) goto <D.42663>; else goto <D.42664>;
  <D.42663>:
  D.42643 = 1;
  return D.42643;
  <D.42664>:
  <D.42662>:
  // predicted unlikely by continue predictor.
  goto <D.25784>;
  <D.25795>:
  <D.25796>:
  <D.25797>:
  <D.25798>:
  D.42649 = (long unsigned int) i;
  D.42650 = D.42649 * 8;
  D.42651 = args + D.42650;
  D.42652 = *D.42651;
  D.42653 = D.42652->type;
  if (D.42653 != 1) goto <D.42665>; else goto <D.42666>;
  <D.42665>:
  D.42649 = (long unsigned int) i;
  D.42650 = D.42649 * 8;
  D.42651 = args + D.42650;
  D.42652 = *D.42651;
  D.42653 = D.42652->type;
  if (D.42653 != 3) goto <D.42667>; else goto <D.42668>;
  <D.42667>:
  D.42649 = (long unsigned int) i;
  D.42650 = D.42649 * 8;
  D.42651 = args + D.42650;
  D.42652 = *D.42651;
  D.42653 = D.42652->type;
  if (D.42653 != 5) goto <D.42669>; else goto <D.42670>;
  <D.42669>:
  D.42649 = (long unsigned int) i;
  D.42650 = D.42649 * 8;
  D.42651 = args + D.42650;
  D.42652 = *D.42651;
  D.42653 = D.42652->type;
  if (D.42653 != 6) goto <D.42671>; else goto <D.42672>;
  <D.42671>:
  D.42643 = 1;
  return D.42643;
  <D.42672>:
  <D.42670>:
  <D.42668>:
  <D.42666>:
  // predicted unlikely by continue predictor.
  goto <D.25784>;
  <D.25799>:
  <D.25800>:
  <D.25801>:
  <D.25802>:
  <D.25803>:
  D.42649 = (long unsigned int) i;
  D.42650 = D.42649 * 8;
  D.42651 = args + D.42650;
  D.42652 = *D.42651;
  D.42653 = D.42652->type;
  if (D.42653 != 6) goto <D.42673>; else goto <D.42674>;
  <D.42673>:
  D.42643 = 1;
  return D.42643;
  <D.42674>:
  // predicted unlikely by continue predictor.
  goto <D.25784>;
  <D.25804>:
  <D.25805>:
  D.42649 = (long unsigned int) i;
  D.42650 = D.42649 * 8;
  D.42651 = args + D.42650;
  D.42652 = *D.42651;
  D.42653 = D.42652->type;
  if (D.42653 != 2) goto <D.42675>; else goto <D.42676>;
  <D.42675>:
  D.42643 = 1;
  return D.42643;
  <D.42676>:
  // predicted unlikely by continue predictor.
  goto <D.25784>;
  <D.25806>:
  <D.25807>:
  D.42649 = (long unsigned int) i;
  D.42650 = D.42649 * 8;
  D.42651 = args + D.42650;
  D.42652 = *D.42651;
  D.42653 = D.42652->type;
  if (D.42653 != 4) goto <D.42677>; else goto <D.42678>;
  <D.42677>:
  D.42643 = 1;
  return D.42643;
  <D.42678>:
  // predicted unlikely by continue predictor.
  goto <D.25784>;
  <D.25808>:
  D.42679 = simple_type->data.klass;
  D.42680 = BIT_FIELD_REF <*D.42679, 64, 256>;
  D.42681 = D.42680 & 576460752303423488;
  if (D.42681 != 0) goto <D.42682>; else goto <D.42683>;
  <D.42682>:
  D.42679 = simple_type->data.klass;
  simple_type = mono_class_enum_basetype (D.42679);
  goto handle_enum;
  <D.42683>:
  D.42649 = (long unsigned int) i;
  D.42650 = D.42649 * 8;
  D.42651 = args + D.42650;
  D.42652 = *D.42651;
  D.42653 = D.42652->type;
  if (D.42653 != 7) goto <D.42684>; else goto <D.42685>;
  <D.42684>:
  D.42643 = 1;
  return D.42643;
  <D.42685>:
  // predicted unlikely by continue predictor.
  goto <D.25784>;
  <D.25809>:
  D.42649 = (long unsigned int) i;
  D.42650 = D.42649 * 8;
  D.42651 = args + D.42650;
  D.42652 = *D.42651;
  D.42653 = D.42652->type;
  if (D.42653 != 7) goto <D.42686>; else goto <D.42687>;
  <D.42686>:
  D.42643 = 1;
  return D.42643;
  <D.42687>:
  // predicted unlikely by continue predictor.
  goto <D.25784>;
  <D.25810>:
  D.42688 = simple_type->data.generic_class;
  D.42689 = D.42688->container_class;
  simple_type = &D.42689->byval_arg;
  goto handle_enum;
  <D.25811>:
  <D.25812>:
  D.42649 = (long unsigned int) i;
  D.42650 = D.42649 * 8;
  D.42651 = args + D.42650;
  D.42652 = *D.42651;
  D.42653 = D.42652->type;
  if (D.42653 != 7) goto <D.42690>; else goto <D.42691>;
  <D.42690>:
  D.42643 = 1;
  return D.42643;
  <D.42691>:
  // predicted unlikely by continue predictor.
  goto <D.25784>;
  <D.25813>:
  D.42659 = simple_type->type;
  D.42660 = (int) D.42659;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in check_call_signature", D.42660);
  <D.25814>:
  goto <D.25814>;
  <D.25784>:
  i = i + 1;
  <D.25816>:
  D.42692 = sig->param_count;
  D.42693 = (int) D.42692;
  if (D.42693 > i) goto <D.25815>; else goto <D.25817>;
  <D.25817>:
  D.42643 = 0;
  return D.42643;
}


handle_array_new (struct MonoCompile * cfg, int rank, struct MonoInst * * sp, unsigned char * ip)
{
  unsigned int D.42695;
  unsigned int D.42696;
  struct MonoInst * D.42697;
  const void * D.42698;
  struct MonoMethodSignature * D.42699;
  struct MonoJitICallInfo * info;

  info = mono_get_array_new_va_icall (rank);
  D.42695 = cfg->flags;
  D.42696 = D.42695 | 8;
  cfg->flags = D.42696;
  cfg->disable_llvm = 1;
  D.42698 = mono_icall_get_wrapper (info);
  D.42699 = info->sig;
  D.42697 = mono_emit_native_call (cfg, D.42698, D.42699, sp);
  return D.42697;
}


emit_init_rvar (struct MonoCompile * cfg, int dreg, struct MonoType * rtype)
{
  unsigned char D.42701;
  long unsigned int D.42702;
  long unsigned int D.42703;
  struct MonoMemPool * D.42706;
  long int D.42707;
  struct MonoInst * D.42708;
  int D.42709;
  int D.42710;
  const unsigned char * D.42711;
  struct MonoBasicBlock * D.42712;
  struct MonoInst * D.42713;
  unsigned int t.358;
  unsigned int D.42719;
  long int D.42722;
  struct MonoInst * D.42723;
  int D.42724;
  int D.42725;
  unsigned int D.42730;
  long int D.42733;
  struct MonoInst * D.42734;
  int D.42735;
  int D.42736;
  unsigned int D.42741;
  long int D.42744;
  struct MonoInst * D.42745;
  int D.42746;
  int D.42747;
  int D.42758;
  long int D.42759;
  struct MonoInst * D.42760;
  int D.42761;
  int D.42762;
  struct MonoClass * D.42763;
  int D.42771;
  long int D.42773;
  struct MonoInst * D.42774;
  int D.42775;
  int D.42776;
  struct MonoClass * D.42777;
  long int D.42781;
  struct MonoInst * D.42782;
  int D.42783;
  int D.42784;
  static double r8_0 = 0.0;
  struct MonoInst * ins;
  int t;

  rtype = mini_replace_type (rtype);
  D.42701 = rtype->type;
  t = (int) D.42701;
  D.42702 = BIT_FIELD_REF <*rtype, 64, 64>;
  D.42703 = D.42702 & 8589934592;
  if (D.42703 != 0) goto <D.42704>; else goto <D.42705>;
  <D.42704>:
  {
    struct MonoInst * inst;

    D.42706 = cfg->mempool;
    inst = mono_mempool_alloc (D.42706, 80);
    inst->data.op[1].const_val = 0;
    D.42707 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42707;
    inst->prev = 0B;
    D.42708 = inst->prev;
    inst->next = D.42708;
    inst->opcode = 363;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42709 = inst->sreg3;
    inst->sreg2 = D.42709;
    D.42710 = inst->sreg2;
    inst->sreg1 = D.42710;
    D.42711 = cfg->ip;
    inst->cil_code = D.42711;
    inst->dreg = dreg;
    inst->data.op[0].p = 0B;
    inst->type = 3;
    D.42712 = cfg->cbb;
    D.42713 = D.42712->last_ins;
    if (D.42713 != 0B) goto <D.42714>; else goto <D.42715>;
    <D.42714>:
    D.42712 = cfg->cbb;
    D.42713 = D.42712->last_ins;
    D.42713->next = inst;
    D.42712 = cfg->cbb;
    D.42713 = D.42712->last_ins;
    inst->prev = D.42713;
    D.42712 = cfg->cbb;
    D.42712->last_ins = inst;
    goto <D.42716>;
    <D.42715>:
    D.42712 = cfg->cbb;
    D.42712 = cfg->cbb;
    D.42712->last_ins = inst;
    D.42713 = D.42712->last_ins;
    D.42712->code = D.42713;
    <D.42716>:
  }
  goto <D.42717>;
  <D.42705>:
  t.358 = (unsigned int) t;
  D.42719 = t.358 + 4294967294;
  if (D.42719 <= 7) goto <D.42720>; else goto <D.42721>;
  <D.42720>:
  {
    struct MonoInst * inst;

    D.42706 = cfg->mempool;
    inst = mono_mempool_alloc (D.42706, 80);
    inst->data.op[1].const_val = 0;
    D.42722 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42722;
    inst->prev = 0B;
    D.42723 = inst->prev;
    inst->next = D.42723;
    inst->opcode = 362;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42724 = inst->sreg3;
    inst->sreg2 = D.42724;
    D.42725 = inst->sreg2;
    inst->sreg1 = D.42725;
    D.42711 = cfg->ip;
    inst->cil_code = D.42711;
    inst->dreg = dreg;
    inst->data.op[0].const_val = 0;
    D.42712 = cfg->cbb;
    D.42713 = D.42712->last_ins;
    if (D.42713 != 0B) goto <D.42726>; else goto <D.42727>;
    <D.42726>:
    D.42712 = cfg->cbb;
    D.42713 = D.42712->last_ins;
    D.42713->next = inst;
    D.42712 = cfg->cbb;
    D.42713 = D.42712->last_ins;
    inst->prev = D.42713;
    D.42712 = cfg->cbb;
    D.42712->last_ins = inst;
    goto <D.42728>;
    <D.42727>:
    D.42712 = cfg->cbb;
    D.42712 = cfg->cbb;
    D.42712->last_ins = inst;
    D.42713 = D.42712->last_ins;
    D.42712->code = D.42713;
    <D.42728>:
  }
  goto <D.42729>;
  <D.42721>:
  t.358 = (unsigned int) t;
  D.42730 = t.358 + 4294967286;
  if (D.42730 <= 1) goto <D.42731>; else goto <D.42732>;
  <D.42731>:
  {
    struct MonoInst * inst;

    D.42706 = cfg->mempool;
    inst = mono_mempool_alloc (D.42706, 80);
    inst->data.op[1].const_val = 0;
    D.42733 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42733;
    inst->prev = 0B;
    D.42734 = inst->prev;
    inst->next = D.42734;
    inst->opcode = 363;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42735 = inst->sreg3;
    inst->sreg2 = D.42735;
    D.42736 = inst->sreg2;
    inst->sreg1 = D.42736;
    D.42711 = cfg->ip;
    inst->cil_code = D.42711;
    inst->dreg = dreg;
    inst->data.i8const = 0;
    D.42712 = cfg->cbb;
    D.42713 = D.42712->last_ins;
    if (D.42713 != 0B) goto <D.42737>; else goto <D.42738>;
    <D.42737>:
    D.42712 = cfg->cbb;
    D.42713 = D.42712->last_ins;
    D.42713->next = inst;
    D.42712 = cfg->cbb;
    D.42713 = D.42712->last_ins;
    inst->prev = D.42713;
    D.42712 = cfg->cbb;
    D.42712->last_ins = inst;
    goto <D.42739>;
    <D.42738>:
    D.42712 = cfg->cbb;
    D.42712 = cfg->cbb;
    D.42712->last_ins = inst;
    D.42713 = D.42712->last_ins;
    D.42712->code = D.42713;
    <D.42739>:
  }
  goto <D.42740>;
  <D.42732>:
  t.358 = (unsigned int) t;
  D.42741 = t.358 + 4294967284;
  if (D.42741 <= 1) goto <D.42742>; else goto <D.42743>;
  <D.42742>:
  D.42706 = cfg->mempool;
  ins = mono_mempool_alloc (D.42706, 80);
  ins->data.op[1].const_val = 0;
  D.42744 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.42744;
  ins->prev = 0B;
  D.42745 = ins->prev;
  ins->next = D.42745;
  ins->opcode = 365;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.42746 = ins->sreg3;
  ins->sreg2 = D.42746;
  D.42747 = ins->sreg2;
  ins->sreg1 = D.42747;
  D.42711 = cfg->ip;
  ins->cil_code = D.42711;
  ins->type = 4;
  ins->data.op[0].p = &r8_0;
  ins->dreg = dreg;
  D.42712 = cfg->cbb;
  D.42713 = D.42712->last_ins;
  if (D.42713 != 0B) goto <D.42748>; else goto <D.42749>;
  <D.42748>:
  D.42712 = cfg->cbb;
  D.42713 = D.42712->last_ins;
  D.42713->next = ins;
  D.42712 = cfg->cbb;
  D.42713 = D.42712->last_ins;
  ins->prev = D.42713;
  D.42712 = cfg->cbb;
  D.42712->last_ins = ins;
  goto <D.42750>;
  <D.42749>:
  D.42712 = cfg->cbb;
  D.42712 = cfg->cbb;
  D.42712->last_ins = ins;
  D.42713 = D.42712->last_ins;
  D.42712->code = D.42713;
  <D.42750>:
  goto <D.42751>;
  <D.42743>:
  if (t == 17) goto <D.42752>; else goto <D.42755>;
  <D.42755>:
  if (t == 22) goto <D.42752>; else goto <D.42756>;
  <D.42756>:
  if (t == 21) goto <D.42757>; else goto <D.42753>;
  <D.42757>:
  D.42758 = mono_type_generic_inst_is_valuetype (rtype);
  if (D.42758 != 0) goto <D.42752>; else goto <D.42753>;
  <D.42752>:
  {
    struct MonoInst * inst;

    D.42706 = cfg->mempool;
    inst = mono_mempool_alloc (D.42706, 80);
    inst->data.op[1].const_val = 0;
    D.42759 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42759;
    inst->prev = 0B;
    D.42760 = inst->prev;
    inst->next = D.42760;
    inst->opcode = 428;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42761 = inst->sreg3;
    inst->sreg2 = D.42761;
    D.42762 = inst->sreg2;
    inst->sreg1 = D.42762;
    D.42711 = cfg->ip;
    inst->cil_code = D.42711;
    inst->dreg = dreg;
    inst->type = 7;
    D.42763 = mono_class_from_mono_type (rtype);
    inst->klass = D.42763;
    D.42712 = cfg->cbb;
    D.42713 = D.42712->last_ins;
    if (D.42713 != 0B) goto <D.42764>; else goto <D.42765>;
    <D.42764>:
    D.42712 = cfg->cbb;
    D.42713 = D.42712->last_ins;
    D.42713->next = inst;
    D.42712 = cfg->cbb;
    D.42713 = D.42712->last_ins;
    inst->prev = D.42713;
    D.42712 = cfg->cbb;
    D.42712->last_ins = inst;
    goto <D.42766>;
    <D.42765>:
    D.42712 = cfg->cbb;
    D.42712 = cfg->cbb;
    D.42712->last_ins = inst;
    D.42713 = D.42712->last_ins;
    D.42712->code = D.42713;
    <D.42766>:
  }
  goto <D.42754>;
  <D.42753>:
  if (t == 19) goto <D.42767>; else goto <D.42770>;
  <D.42770>:
  if (t == 30) goto <D.42767>; else goto <D.42768>;
  <D.42767>:
  D.42771 = mini_type_var_is_vt (cfg, rtype);
  if (D.42771 != 0) goto <D.42772>; else goto <D.42768>;
  <D.42772>:
  {
    struct MonoInst * inst;

    D.42706 = cfg->mempool;
    inst = mono_mempool_alloc (D.42706, 80);
    inst->data.op[1].const_val = 0;
    D.42773 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42773;
    inst->prev = 0B;
    D.42774 = inst->prev;
    inst->next = D.42774;
    inst->opcode = 428;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42775 = inst->sreg3;
    inst->sreg2 = D.42775;
    D.42776 = inst->sreg2;
    inst->sreg1 = D.42776;
    D.42711 = cfg->ip;
    inst->cil_code = D.42711;
    inst->dreg = dreg;
    inst->type = 7;
    D.42777 = mono_class_from_mono_type (rtype);
    inst->klass = D.42777;
    D.42712 = cfg->cbb;
    D.42713 = D.42712->last_ins;
    if (D.42713 != 0B) goto <D.42778>; else goto <D.42779>;
    <D.42778>:
    D.42712 = cfg->cbb;
    D.42713 = D.42712->last_ins;
    D.42713->next = inst;
    D.42712 = cfg->cbb;
    D.42713 = D.42712->last_ins;
    inst->prev = D.42713;
    D.42712 = cfg->cbb;
    D.42712->last_ins = inst;
    goto <D.42780>;
    <D.42779>:
    D.42712 = cfg->cbb;
    D.42712 = cfg->cbb;
    D.42712->last_ins = inst;
    D.42713 = D.42712->last_ins;
    D.42712->code = D.42713;
    <D.42780>:
  }
  goto <D.42769>;
  <D.42768>:
  {
    struct MonoInst * inst;

    D.42706 = cfg->mempool;
    inst = mono_mempool_alloc (D.42706, 80);
    inst->data.op[1].const_val = 0;
    D.42781 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.42781;
    inst->prev = 0B;
    D.42782 = inst->prev;
    inst->next = D.42782;
    inst->opcode = 363;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.42783 = inst->sreg3;
    inst->sreg2 = D.42783;
    D.42784 = inst->sreg2;
    inst->sreg1 = D.42784;
    D.42711 = cfg->ip;
    inst->cil_code = D.42711;
    inst->dreg = dreg;
    inst->data.op[0].p = 0B;
    inst->type = 3;
    D.42712 = cfg->cbb;
    D.42713 = D.42712->last_ins;
    if (D.42713 != 0B) goto <D.42785>; else goto <D.42786>;
    <D.42785>:
    D.42712 = cfg->cbb;
    D.42713 = D.42712->last_ins;
    D.42713->next = inst;
    D.42712 = cfg->cbb;
    D.42713 = D.42712->last_ins;
    inst->prev = D.42713;
    D.42712 = cfg->cbb;
    D.42712->last_ins = inst;
    goto <D.42787>;
    <D.42786>:
    D.42712 = cfg->cbb;
    D.42712 = cfg->cbb;
    D.42712->last_ins = inst;
    D.42713 = D.42712->last_ins;
    D.42712->code = D.42713;
    <D.42787>:
  }
  <D.42769>:
  <D.42754>:
  <D.42751>:
  <D.42740>:
  <D.42729>:
  <D.42717>:
}


handle_alloc (struct MonoCompile * cfg, struct MonoClass * klass, gboolean for_box, int context_used)
{
  unsigned int D.42790;
  unsigned int D.42791;
  <unnamed type> rgctx_info.359;
  long unsigned int D.42802;
  long unsigned int D.42803;
  struct MonoMemPool * D.42804;
  void * D.42805;
  struct MonoInst * D.42806;
  long int D.42807;
  struct MonoInst * D.42808;
  int D.42809;
  int D.42810;
  const unsigned char * D.42811;
  struct MonoInst * * D.42812;
  long int D.42813;
  long unsigned int D.42814;
  long unsigned int D.42815;
  struct MonoInst * * D.42816;
  struct MonoInst * D.42817;
  struct MonoType * D.42818;
  unsigned int D.42819;
  short unsigned int D.42820;
  struct MonoClass * D.42821;
  int D.42822;
  unsigned char D.42823;
  <unnamed type> D.42824;
  unsigned int D.42825;
  int D.42826;
  short unsigned int D.42827;
  struct MonoClass * D.42830;
  void * D.42831;
  struct MonoDomain * D.42832;
  unsigned int D.42833;
  int D.42834;
  struct MonoBasicBlock * D.42835;
  struct MonoInst * D.42836;
  struct MonoInst * D.42845;
  void * D.42852;
  struct MonoInst * D.42853;
  long int D.42854;
  struct MonoInst * D.42855;
  int D.42856;
  int D.42857;
  long int D.42858;
  long unsigned int D.42859;
  long unsigned int D.42860;
  struct MonoInst * * D.42861;
  struct MonoInst * D.42862;
  struct MonoType * D.42863;
  unsigned int D.42864;
  short unsigned int D.42865;
  struct MonoClass * D.42866;
  int D.42867;
  unsigned char D.42868;
  <unnamed type> D.42869;
  unsigned int D.42870;
  int D.42871;
  short unsigned int D.42872;
  struct MonoClass * D.42875;
  void * D.42876;
  unsigned int D.42877;
  int D.42878;
  void * D.42882;
  struct MonoInst * D.42883;
  long int D.42884;
  struct MonoInst * D.42885;
  guint16 iftmp.360;
  int D.42890;
  int D.42891;
  unsigned int D.42892;
  int D.42893;
  long unsigned int D.42900;
  long unsigned int D.42901;
  unsigned int D.42903;
  struct MonoImage * D.42905;
  struct MonoImage * D.42906;
  struct MonoGenericClass * D.42908;
  void * D.42910;
  long int D.42911;
  long int D.42912;
  unsigned int D.42913;
  int D.42914;
  void * D.42922;
  guint16 iftmp.361;
  void * iftmp.362;
  unsigned int D.42931;
  int D.42932;
  int pass_lw.363;
  struct MonoClass * D.42939;
  int D.42940;
  long unsigned int D.42941;
  long unsigned int D.42942;
  long unsigned int D.42943;
  void * D.42944;
  long int D.42945;
  unsigned int D.42946;
  int D.42947;
  void * D.42951;
  guint16 iftmp.364;
  void * iftmp.365;
  unsigned int D.42960;
  int D.42961;
  void * D.42966;
  guint16 iftmp.366;
  void * iftmp.367;
  unsigned int D.42975;
  int D.42976;
  struct MonoInst * iargs[2];
  void * alloc_ftn;

  try
    {
      if (context_used != 0) goto <D.42788>; else goto <D.42789>;
      <D.42788>:
      {
        struct MonoInst * data;
        int rgctx_info;
        struct MonoInst * iargs[2];
        struct MonoMethod * managed_alloc;

        try
          {
            managed_alloc = mono_gc_get_managed_allocator (klass, for_box);
            D.42790 = cfg->opt;
            D.42791 = D.42790 & 512;
            if (D.42791 != 0) goto <D.42792>; else goto <D.42793>;
            <D.42792>:
            rgctx_info = 1;
            goto <D.42794>;
            <D.42793>:
            rgctx_info = 2;
            <D.42794>:
            rgctx_info.359 = (<unnamed type>) rgctx_info;
            data = emit_get_rgctx_klass (cfg, context_used, klass, rgctx_info.359);
            D.42790 = cfg->opt;
            D.42791 = D.42790 & 512;
            if (D.42791 != 0) goto <D.42796>; else goto <D.42797>;
            <D.42796>:
            D.42790 = cfg->opt;
            D.42791 = D.42790 & 512;
            if (D.42791 != 0) goto <D.42798>; else goto <D.42801>;
            <D.42801>:
            D.42802 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.42803 = D.42802 & 33554432;
            if (D.42803 != 0) goto <D.42798>; else goto <D.42799>;
            <D.42798>:
            {
              struct MonoInst * __domain_var;

              __domain_var = mono_get_domainvar (cfg);
              D.42804 = cfg->mempool;
              D.42805 = mono_mempool_alloc (D.42804, 80);
              iargs[0] = D.42805;
              D.42806 = iargs[0];
              D.42806 = iargs[0];
              D.42806->data.op[1].const_val = 0;
              D.42807 = D.42806->data.op[1].const_val;
              D.42806->data.op[0].const_val = D.42807;
              D.42806 = iargs[0];
              D.42806 = iargs[0];
              D.42806->prev = 0B;
              D.42808 = D.42806->prev;
              D.42806->next = D.42808;
              D.42806 = iargs[0];
              D.42806->opcode = 424;
              D.42806 = iargs[0];
              D.42806->flags = 0;
              D.42806 = iargs[0];
              D.42806->type = 0;
              D.42806 = iargs[0];
              D.42806->dreg = -1;
              D.42806 = iargs[0];
              D.42806 = iargs[0];
              D.42806 = iargs[0];
              D.42806->sreg3 = -1;
              D.42809 = D.42806->sreg3;
              D.42806->sreg2 = D.42809;
              D.42810 = D.42806->sreg2;
              D.42806->sreg1 = D.42810;
              D.42806 = iargs[0];
              D.42811 = cfg->ip;
              D.42806->cil_code = D.42811;
              D.42806 = iargs[0];
              D.42812 = cfg->varinfo;
              D.42813 = __domain_var->data.op[0].const_val;
              D.42814 = (long unsigned int) D.42813;
              D.42815 = D.42814 * 8;
              D.42816 = D.42812 + D.42815;
              D.42817 = *D.42816;
              D.42818 = D.42817->data.op[1].vtype;
              D.42819 = mono_type_to_regmove (cfg, D.42818);
              D.42820 = (short unsigned int) D.42819;
              D.42806->opcode = D.42820;
              D.42812 = cfg->varinfo;
              D.42813 = __domain_var->data.op[0].const_val;
              D.42814 = (long unsigned int) D.42813;
              D.42815 = D.42814 * 8;
              D.42816 = D.42812 + D.42815;
              D.42817 = *D.42816;
              D.42818 = D.42817->data.op[1].vtype;
              D.42806 = iargs[0];
              type_to_eval_stack_type (cfg, D.42818, D.42806);
              D.42806 = iargs[0];
              D.42812 = cfg->varinfo;
              D.42813 = __domain_var->data.op[0].const_val;
              D.42814 = (long unsigned int) D.42813;
              D.42815 = D.42814 * 8;
              D.42816 = D.42812 + D.42815;
              D.42817 = *D.42816;
              D.42821 = D.42817->klass;
              D.42806->klass = D.42821;
              D.42806 = iargs[0];
              D.42812 = cfg->varinfo;
              D.42813 = __domain_var->data.op[0].const_val;
              D.42814 = (long unsigned int) D.42813;
              D.42815 = D.42814 * 8;
              D.42816 = D.42812 + D.42815;
              D.42817 = *D.42816;
              D.42822 = D.42817->dreg;
              D.42806->sreg1 = D.42822;
              D.42806 = iargs[0];
              D.42806 = iargs[0];
              D.42823 = D.42806->type;
              D.42824 = (<unnamed type>) D.42823;
              D.42825 = alloc_dreg (cfg, D.42824);
              D.42826 = (int) D.42825;
              D.42806->dreg = D.42826;
              D.42806 = iargs[0];
              D.42827 = D.42806->opcode;
              if (D.42827 == 427) goto <D.42828>; else goto <D.42829>;
              <D.42828>:
              D.42806 = iargs[0];
              D.42812 = cfg->varinfo;
              D.42813 = __domain_var->data.op[0].const_val;
              D.42814 = (long unsigned int) D.42813;
              D.42815 = D.42814 * 8;
              D.42816 = D.42812 + D.42815;
              D.42817 = *D.42816;
              D.42818 = D.42817->data.op[1].vtype;
              D.42830 = mono_class_from_mono_type (D.42818);
              D.42806->klass = D.42830;
              <D.42829>:
            }
            goto <D.42800>;
            <D.42799>:
            D.42804 = cfg->mempool;
            D.42831 = mono_mempool_alloc (D.42804, 80);
            iargs[0] = D.42831;
            D.42806 = iargs[0];
            D.42806 = iargs[0];
            D.42806->data.op[1].const_val = 0;
            D.42807 = D.42806->data.op[1].const_val;
            D.42806->data.op[0].const_val = D.42807;
            D.42806 = iargs[0];
            D.42806 = iargs[0];
            D.42806->prev = 0B;
            D.42808 = D.42806->prev;
            D.42806->next = D.42808;
            D.42806 = iargs[0];
            D.42806->opcode = 363;
            D.42806 = iargs[0];
            D.42806->flags = 0;
            D.42806 = iargs[0];
            D.42806->type = 0;
            D.42806 = iargs[0];
            D.42806->dreg = -1;
            D.42806 = iargs[0];
            D.42806 = iargs[0];
            D.42806 = iargs[0];
            D.42806->sreg3 = -1;
            D.42809 = D.42806->sreg3;
            D.42806->sreg2 = D.42809;
            D.42810 = D.42806->sreg2;
            D.42806->sreg1 = D.42810;
            D.42806 = iargs[0];
            D.42811 = cfg->ip;
            D.42806->cil_code = D.42811;
            D.42806 = iargs[0];
            D.42832 = cfg->domain;
            D.42806->data.op[0].p = D.42832;
            D.42806 = iargs[0];
            D.42806->type = 3;
            D.42806 = iargs[0];
            D.42833 = alloc_dreg (cfg, 3);
            D.42834 = (int) D.42833;
            D.42806->dreg = D.42834;
            <D.42800>:
            D.42835 = cfg->cbb;
            D.42836 = D.42835->last_ins;
            if (D.42836 != 0B) goto <D.42837>; else goto <D.42838>;
            <D.42837>:
            D.42835 = cfg->cbb;
            D.42836 = D.42835->last_ins;
            D.42806 = iargs[0];
            D.42836->next = D.42806;
            D.42806 = iargs[0];
            D.42835 = cfg->cbb;
            D.42836 = D.42835->last_ins;
            D.42806->prev = D.42836;
            D.42835 = cfg->cbb;
            D.42806 = iargs[0];
            D.42835->last_ins = D.42806;
            goto <D.42839>;
            <D.42838>:
            D.42835 = cfg->cbb;
            D.42835 = cfg->cbb;
            D.42806 = iargs[0];
            D.42835->last_ins = D.42806;
            D.42836 = D.42835->last_ins;
            D.42835->code = D.42836;
            <D.42839>:
            iargs[1] = data;
            alloc_ftn = mono_object_new;
            goto <D.42840>;
            <D.42797>:
            iargs[0] = data;
            alloc_ftn = mono_object_new_specific;
            <D.42840>:
            if (managed_alloc != 0B) goto <D.42841>; else goto <D.42842>;
            <D.42841>:
            D.42790 = cfg->opt;
            D.42791 = D.42790 & 512;
            if (D.42791 == 0) goto <D.42843>; else goto <D.42844>;
            <D.42843>:
            D.42845 = mono_emit_method_call (cfg, managed_alloc, &iargs, 0B);
            return D.42845;
            <D.42844>:
            <D.42842>:
            D.42845 = mono_emit_jit_icall (cfg, alloc_ftn, &iargs);
            return D.42845;
          }
        finally
          {
            iargs = {CLOBBER};
          }
      }
      <D.42789>:
      D.42790 = cfg->opt;
      D.42791 = D.42790 & 512;
      if (D.42791 != 0) goto <D.42846>; else goto <D.42847>;
      <D.42846>:
      D.42790 = cfg->opt;
      D.42791 = D.42790 & 512;
      if (D.42791 != 0) goto <D.42848>; else goto <D.42851>;
      <D.42851>:
      D.42802 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.42803 = D.42802 & 33554432;
      if (D.42803 != 0) goto <D.42848>; else goto <D.42849>;
      <D.42848>:
      {
        struct MonoInst * __domain_var;

        __domain_var = mono_get_domainvar (cfg);
        D.42804 = cfg->mempool;
        D.42852 = mono_mempool_alloc (D.42804, 80);
        iargs[0] = D.42852;
        D.42853 = iargs[0];
        D.42853 = iargs[0];
        D.42853->data.op[1].const_val = 0;
        D.42854 = D.42853->data.op[1].const_val;
        D.42853->data.op[0].const_val = D.42854;
        D.42853 = iargs[0];
        D.42853 = iargs[0];
        D.42853->prev = 0B;
        D.42855 = D.42853->prev;
        D.42853->next = D.42855;
        D.42853 = iargs[0];
        D.42853->opcode = 424;
        D.42853 = iargs[0];
        D.42853->flags = 0;
        D.42853 = iargs[0];
        D.42853->type = 0;
        D.42853 = iargs[0];
        D.42853->dreg = -1;
        D.42853 = iargs[0];
        D.42853 = iargs[0];
        D.42853 = iargs[0];
        D.42853->sreg3 = -1;
        D.42856 = D.42853->sreg3;
        D.42853->sreg2 = D.42856;
        D.42857 = D.42853->sreg2;
        D.42853->sreg1 = D.42857;
        D.42853 = iargs[0];
        D.42811 = cfg->ip;
        D.42853->cil_code = D.42811;
        D.42853 = iargs[0];
        D.42812 = cfg->varinfo;
        D.42858 = __domain_var->data.op[0].const_val;
        D.42859 = (long unsigned int) D.42858;
        D.42860 = D.42859 * 8;
        D.42861 = D.42812 + D.42860;
        D.42862 = *D.42861;
        D.42863 = D.42862->data.op[1].vtype;
        D.42864 = mono_type_to_regmove (cfg, D.42863);
        D.42865 = (short unsigned int) D.42864;
        D.42853->opcode = D.42865;
        D.42812 = cfg->varinfo;
        D.42858 = __domain_var->data.op[0].const_val;
        D.42859 = (long unsigned int) D.42858;
        D.42860 = D.42859 * 8;
        D.42861 = D.42812 + D.42860;
        D.42862 = *D.42861;
        D.42863 = D.42862->data.op[1].vtype;
        D.42853 = iargs[0];
        type_to_eval_stack_type (cfg, D.42863, D.42853);
        D.42853 = iargs[0];
        D.42812 = cfg->varinfo;
        D.42858 = __domain_var->data.op[0].const_val;
        D.42859 = (long unsigned int) D.42858;
        D.42860 = D.42859 * 8;
        D.42861 = D.42812 + D.42860;
        D.42862 = *D.42861;
        D.42866 = D.42862->klass;
        D.42853->klass = D.42866;
        D.42853 = iargs[0];
        D.42812 = cfg->varinfo;
        D.42858 = __domain_var->data.op[0].const_val;
        D.42859 = (long unsigned int) D.42858;
        D.42860 = D.42859 * 8;
        D.42861 = D.42812 + D.42860;
        D.42862 = *D.42861;
        D.42867 = D.42862->dreg;
        D.42853->sreg1 = D.42867;
        D.42853 = iargs[0];
        D.42853 = iargs[0];
        D.42868 = D.42853->type;
        D.42869 = (<unnamed type>) D.42868;
        D.42870 = alloc_dreg (cfg, D.42869);
        D.42871 = (int) D.42870;
        D.42853->dreg = D.42871;
        D.42853 = iargs[0];
        D.42872 = D.42853->opcode;
        if (D.42872 == 427) goto <D.42873>; else goto <D.42874>;
        <D.42873>:
        D.42853 = iargs[0];
        D.42812 = cfg->varinfo;
        D.42858 = __domain_var->data.op[0].const_val;
        D.42859 = (long unsigned int) D.42858;
        D.42860 = D.42859 * 8;
        D.42861 = D.42812 + D.42860;
        D.42862 = *D.42861;
        D.42863 = D.42862->data.op[1].vtype;
        D.42875 = mono_class_from_mono_type (D.42863);
        D.42853->klass = D.42875;
        <D.42874>:
      }
      goto <D.42850>;
      <D.42849>:
      D.42804 = cfg->mempool;
      D.42876 = mono_mempool_alloc (D.42804, 80);
      iargs[0] = D.42876;
      D.42853 = iargs[0];
      D.42853 = iargs[0];
      D.42853->data.op[1].const_val = 0;
      D.42854 = D.42853->data.op[1].const_val;
      D.42853->data.op[0].const_val = D.42854;
      D.42853 = iargs[0];
      D.42853 = iargs[0];
      D.42853->prev = 0B;
      D.42855 = D.42853->prev;
      D.42853->next = D.42855;
      D.42853 = iargs[0];
      D.42853->opcode = 363;
      D.42853 = iargs[0];
      D.42853->flags = 0;
      D.42853 = iargs[0];
      D.42853->type = 0;
      D.42853 = iargs[0];
      D.42853->dreg = -1;
      D.42853 = iargs[0];
      D.42853 = iargs[0];
      D.42853 = iargs[0];
      D.42853->sreg3 = -1;
      D.42856 = D.42853->sreg3;
      D.42853->sreg2 = D.42856;
      D.42857 = D.42853->sreg2;
      D.42853->sreg1 = D.42857;
      D.42853 = iargs[0];
      D.42811 = cfg->ip;
      D.42853->cil_code = D.42811;
      D.42853 = iargs[0];
      D.42832 = cfg->domain;
      D.42853->data.op[0].p = D.42832;
      D.42853 = iargs[0];
      D.42853->type = 3;
      D.42853 = iargs[0];
      D.42877 = alloc_dreg (cfg, 3);
      D.42878 = (int) D.42877;
      D.42853->dreg = D.42878;
      <D.42850>:
      D.42835 = cfg->cbb;
      D.42836 = D.42835->last_ins;
      if (D.42836 != 0B) goto <D.42879>; else goto <D.42880>;
      <D.42879>:
      D.42835 = cfg->cbb;
      D.42836 = D.42835->last_ins;
      D.42853 = iargs[0];
      D.42836->next = D.42853;
      D.42853 = iargs[0];
      D.42835 = cfg->cbb;
      D.42836 = D.42835->last_ins;
      D.42853->prev = D.42836;
      D.42835 = cfg->cbb;
      D.42853 = iargs[0];
      D.42835->last_ins = D.42853;
      goto <D.42881>;
      <D.42880>:
      D.42835 = cfg->cbb;
      D.42835 = cfg->cbb;
      D.42853 = iargs[0];
      D.42835->last_ins = D.42853;
      D.42836 = D.42835->last_ins;
      D.42835->code = D.42836;
      <D.42881>:
      D.42804 = cfg->mempool;
      D.42882 = mono_mempool_alloc (D.42804, 80);
      iargs[1] = D.42882;
      D.42883 = iargs[1];
      D.42883 = iargs[1];
      D.42883->data.op[1].const_val = 0;
      D.42884 = D.42883->data.op[1].const_val;
      D.42883->data.op[0].const_val = D.42884;
      D.42883 = iargs[1];
      D.42883 = iargs[1];
      D.42883->prev = 0B;
      D.42885 = D.42883->prev;
      D.42883->next = D.42885;
      D.42883 = iargs[1];
      D.42802 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.42803 = D.42802 & 33554432;
      if (D.42803 != 0) goto <D.42887>; else goto <D.42888>;
      <D.42887>:
      iftmp.360 = 732;
      goto <D.42889>;
      <D.42888>:
      iftmp.360 = 363;
      <D.42889>:
      D.42883->opcode = iftmp.360;
      D.42883 = iargs[1];
      D.42883->flags = 0;
      D.42883 = iargs[1];
      D.42883->type = 0;
      D.42883 = iargs[1];
      D.42883->dreg = -1;
      D.42883 = iargs[1];
      D.42883 = iargs[1];
      D.42883 = iargs[1];
      D.42883->sreg3 = -1;
      D.42890 = D.42883->sreg3;
      D.42883->sreg2 = D.42890;
      D.42891 = D.42883->sreg2;
      D.42883->sreg1 = D.42891;
      D.42883 = iargs[1];
      D.42811 = cfg->ip;
      D.42883->cil_code = D.42811;
      D.42883 = iargs[1];
      D.42883->data.op[0].p = klass;
      D.42883 = iargs[1];
      D.42883->data.op[1].src = 11B;
      D.42883 = iargs[1];
      D.42883->type = 3;
      D.42883 = iargs[1];
      D.42892 = alloc_dreg (cfg, 3);
      D.42893 = (int) D.42892;
      D.42883->dreg = D.42893;
      D.42835 = cfg->cbb;
      D.42836 = D.42835->last_ins;
      if (D.42836 != 0B) goto <D.42894>; else goto <D.42895>;
      <D.42894>:
      D.42835 = cfg->cbb;
      D.42836 = D.42835->last_ins;
      D.42883 = iargs[1];
      D.42836->next = D.42883;
      D.42883 = iargs[1];
      D.42835 = cfg->cbb;
      D.42836 = D.42835->last_ins;
      D.42883->prev = D.42836;
      D.42835 = cfg->cbb;
      D.42883 = iargs[1];
      D.42835->last_ins = D.42883;
      goto <D.42896>;
      <D.42895>:
      D.42835 = cfg->cbb;
      D.42835 = cfg->cbb;
      D.42883 = iargs[1];
      D.42835->last_ins = D.42883;
      D.42836 = D.42835->last_ins;
      D.42835->code = D.42836;
      <D.42896>:
      alloc_ftn = mono_object_new;
      goto <D.42897>;
      <D.42847>:
      D.42802 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.42803 = D.42802 & 33554432;
      if (D.42803 != 0) goto <D.42899>; else goto <D.42898>;
      <D.42899>:
      D.42835 = cfg->cbb;
      D.42900 = BIT_FIELD_REF <*D.42835, 64, 1472>;
      D.42901 = D.42900 & 140737488355328;
      if (D.42901 != 0) goto <D.42902>; else goto <D.42898>;
      <D.42902>:
      D.42903 = klass->type_token;
      if (D.42903 != 0) goto <D.42904>; else goto <D.42898>;
      <D.42904>:
      D.42905 = klass->image;
      D.42906 = mono_defaults.corlib;
      if (D.42905 == D.42906) goto <D.42907>; else goto <D.42898>;
      <D.42907>:
      D.42908 = klass->generic_class;
      if (D.42908 == 0B) goto <D.42909>; else goto <D.42898>;
      <D.42909>:
      D.42804 = cfg->mempool;
      D.42910 = mono_mempool_alloc (D.42804, 80);
      iargs[0] = D.42910;
      D.42853 = iargs[0];
      D.42853 = iargs[0];
      D.42853->data.op[1].const_val = 0;
      D.42854 = D.42853->data.op[1].const_val;
      D.42853->data.op[0].const_val = D.42854;
      D.42853 = iargs[0];
      D.42853 = iargs[0];
      D.42853->prev = 0B;
      D.42855 = D.42853->prev;
      D.42853->next = D.42855;
      D.42853 = iargs[0];
      D.42853->opcode = 362;
      D.42853 = iargs[0];
      D.42853->flags = 0;
      D.42853 = iargs[0];
      D.42853->type = 0;
      D.42853 = iargs[0];
      D.42853->dreg = -1;
      D.42853 = iargs[0];
      D.42853 = iargs[0];
      D.42853 = iargs[0];
      D.42853->sreg3 = -1;
      D.42856 = D.42853->sreg3;
      D.42853->sreg2 = D.42856;
      D.42857 = D.42853->sreg2;
      D.42853->sreg1 = D.42857;
      D.42853 = iargs[0];
      D.42811 = cfg->ip;
      D.42853->cil_code = D.42811;
      D.42853 = iargs[0];
      D.42903 = klass->type_token;
      D.42911 = (long int) D.42903;
      D.42912 = D.42911 & 16777215;
      D.42853->data.op[0].const_val = D.42912;
      D.42853 = iargs[0];
      D.42853->type = 1;
      D.42853 = iargs[0];
      D.42913 = alloc_dreg (cfg, 1);
      D.42914 = (int) D.42913;
      D.42853->dreg = D.42914;
      D.42835 = cfg->cbb;
      D.42836 = D.42835->last_ins;
      if (D.42836 != 0B) goto <D.42915>; else goto <D.42916>;
      <D.42915>:
      D.42835 = cfg->cbb;
      D.42836 = D.42835->last_ins;
      D.42853 = iargs[0];
      D.42836->next = D.42853;
      D.42853 = iargs[0];
      D.42835 = cfg->cbb;
      D.42836 = D.42835->last_ins;
      D.42853->prev = D.42836;
      D.42835 = cfg->cbb;
      D.42853 = iargs[0];
      D.42835->last_ins = D.42853;
      goto <D.42917>;
      <D.42916>:
      D.42835 = cfg->cbb;
      D.42835 = cfg->cbb;
      D.42853 = iargs[0];
      D.42835->last_ins = D.42853;
      D.42836 = D.42835->last_ins;
      D.42835->code = D.42836;
      <D.42917>:
      D.42845 = mono_emit_jit_icall (cfg, mono_helper_newobj_mscorlib, &iargs);
      return D.42845;
      <D.42898>:
      {
        struct MonoVTable * vtable;
        struct MonoMethod * managed_alloc;
        gboolean pass_lw;

        try
          {
            D.42832 = cfg->domain;
            vtable = mono_class_vtable (D.42832, klass);
            managed_alloc = 0B;
            if (vtable == 0B) goto <D.42918>; else goto <D.42919>;
            <D.42918>:
            mono_cfg_set_exception (cfg, 7);
            cfg->exception_ptr = klass;
            D.42845 = 0B;
            return D.42845;
            <D.42919>:
            managed_alloc = mono_gc_get_managed_allocator (klass, for_box);
            if (managed_alloc != 0B) goto <D.42920>; else goto <D.42921>;
            <D.42920>:
            D.42804 = cfg->mempool;
            D.42922 = mono_mempool_alloc (D.42804, 80);
            iargs[0] = D.42922;
            D.42853 = iargs[0];
            D.42853 = iargs[0];
            D.42853->data.op[1].const_val = 0;
            D.42854 = D.42853->data.op[1].const_val;
            D.42853->data.op[0].const_val = D.42854;
            D.42853 = iargs[0];
            D.42853 = iargs[0];
            D.42853->prev = 0B;
            D.42855 = D.42853->prev;
            D.42853->next = D.42855;
            D.42853 = iargs[0];
            D.42802 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.42803 = D.42802 & 33554432;
            if (D.42803 != 0) goto <D.42924>; else goto <D.42925>;
            <D.42924>:
            iftmp.361 = 732;
            goto <D.42926>;
            <D.42925>:
            iftmp.361 = 363;
            <D.42926>:
            D.42853->opcode = iftmp.361;
            D.42853 = iargs[0];
            D.42853->flags = 0;
            D.42853 = iargs[0];
            D.42853->type = 0;
            D.42853 = iargs[0];
            D.42853->dreg = -1;
            D.42853 = iargs[0];
            D.42853 = iargs[0];
            D.42853 = iargs[0];
            D.42853->sreg3 = -1;
            D.42856 = D.42853->sreg3;
            D.42853->sreg2 = D.42856;
            D.42857 = D.42853->sreg2;
            D.42853->sreg1 = D.42857;
            D.42853 = iargs[0];
            D.42811 = cfg->ip;
            D.42853->cil_code = D.42811;
            D.42853 = iargs[0];
            D.42802 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.42803 = D.42802 & 33554432;
            if (D.42803 != 0) goto <D.42928>; else goto <D.42929>;
            <D.42928>:
            iftmp.362 = vtable->klass;
            goto <D.42930>;
            <D.42929>:
            iftmp.362 = vtable;
            <D.42930>:
            D.42853->data.op[0].p = iftmp.362;
            D.42853 = iargs[0];
            D.42853->data.op[1].src = 14B;
            D.42853 = iargs[0];
            D.42853->type = 3;
            D.42853 = iargs[0];
            D.42931 = alloc_dreg (cfg, 3);
            D.42932 = (int) D.42931;
            D.42853->dreg = D.42932;
            D.42835 = cfg->cbb;
            D.42836 = D.42835->last_ins;
            if (D.42836 != 0B) goto <D.42933>; else goto <D.42934>;
            <D.42933>:
            D.42835 = cfg->cbb;
            D.42836 = D.42835->last_ins;
            D.42853 = iargs[0];
            D.42836->next = D.42853;
            D.42853 = iargs[0];
            D.42835 = cfg->cbb;
            D.42836 = D.42835->last_ins;
            D.42853->prev = D.42836;
            D.42835 = cfg->cbb;
            D.42853 = iargs[0];
            D.42835->last_ins = D.42853;
            goto <D.42935>;
            <D.42934>:
            D.42835 = cfg->cbb;
            D.42835 = cfg->cbb;
            D.42853 = iargs[0];
            D.42835->last_ins = D.42853;
            D.42836 = D.42835->last_ins;
            D.42835->code = D.42836;
            <D.42935>:
            D.42845 = mono_emit_method_call (cfg, managed_alloc, &iargs, 0B);
            return D.42845;
            <D.42921>:
            alloc_ftn = mono_class_get_allocation_ftn (vtable, for_box, &pass_lw);
            pass_lw.363 = pass_lw;
            if (pass_lw.363 != 0) goto <D.42937>; else goto <D.42938>;
            <D.42937>:
            {
              guint32 lw;

              D.42939 = vtable->klass;
              D.42940 = D.42939->instance_size;
              lw = (guint32) D.42940;
              D.42941 = (long unsigned int) lw;
              D.42942 = D.42941 + 7;
              D.42943 = D.42942 >> 3;
              lw = (guint32) D.42943;
              D.42804 = cfg->mempool;
              D.42944 = mono_mempool_alloc (D.42804, 80);
              iargs[0] = D.42944;
              D.42853 = iargs[0];
              D.42853 = iargs[0];
              D.42853->data.op[1].const_val = 0;
              D.42854 = D.42853->data.op[1].const_val;
              D.42853->data.op[0].const_val = D.42854;
              D.42853 = iargs[0];
              D.42853 = iargs[0];
              D.42853->prev = 0B;
              D.42855 = D.42853->prev;
              D.42853->next = D.42855;
              D.42853 = iargs[0];
              D.42853->opcode = 362;
              D.42853 = iargs[0];
              D.42853->flags = 0;
              D.42853 = iargs[0];
              D.42853->type = 0;
              D.42853 = iargs[0];
              D.42853->dreg = -1;
              D.42853 = iargs[0];
              D.42853 = iargs[0];
              D.42853 = iargs[0];
              D.42853->sreg3 = -1;
              D.42856 = D.42853->sreg3;
              D.42853->sreg2 = D.42856;
              D.42857 = D.42853->sreg2;
              D.42853->sreg1 = D.42857;
              D.42853 = iargs[0];
              D.42811 = cfg->ip;
              D.42853->cil_code = D.42811;
              D.42853 = iargs[0];
              D.42945 = (long int) lw;
              D.42853->data.op[0].const_val = D.42945;
              D.42853 = iargs[0];
              D.42853->type = 1;
              D.42853 = iargs[0];
              D.42946 = alloc_dreg (cfg, 1);
              D.42947 = (int) D.42946;
              D.42853->dreg = D.42947;
              D.42835 = cfg->cbb;
              D.42836 = D.42835->last_ins;
              if (D.42836 != 0B) goto <D.42948>; else goto <D.42949>;
              <D.42948>:
              D.42835 = cfg->cbb;
              D.42836 = D.42835->last_ins;
              D.42853 = iargs[0];
              D.42836->next = D.42853;
              D.42853 = iargs[0];
              D.42835 = cfg->cbb;
              D.42836 = D.42835->last_ins;
              D.42853->prev = D.42836;
              D.42835 = cfg->cbb;
              D.42853 = iargs[0];
              D.42835->last_ins = D.42853;
              goto <D.42950>;
              <D.42949>:
              D.42835 = cfg->cbb;
              D.42835 = cfg->cbb;
              D.42853 = iargs[0];
              D.42835->last_ins = D.42853;
              D.42836 = D.42835->last_ins;
              D.42835->code = D.42836;
              <D.42950>:
              D.42804 = cfg->mempool;
              D.42951 = mono_mempool_alloc (D.42804, 80);
              iargs[1] = D.42951;
              D.42883 = iargs[1];
              D.42883 = iargs[1];
              D.42883->data.op[1].const_val = 0;
              D.42884 = D.42883->data.op[1].const_val;
              D.42883->data.op[0].const_val = D.42884;
              D.42883 = iargs[1];
              D.42883 = iargs[1];
              D.42883->prev = 0B;
              D.42885 = D.42883->prev;
              D.42883->next = D.42885;
              D.42883 = iargs[1];
              D.42802 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.42803 = D.42802 & 33554432;
              if (D.42803 != 0) goto <D.42953>; else goto <D.42954>;
              <D.42953>:
              iftmp.364 = 732;
              goto <D.42955>;
              <D.42954>:
              iftmp.364 = 363;
              <D.42955>:
              D.42883->opcode = iftmp.364;
              D.42883 = iargs[1];
              D.42883->flags = 0;
              D.42883 = iargs[1];
              D.42883->type = 0;
              D.42883 = iargs[1];
              D.42883->dreg = -1;
              D.42883 = iargs[1];
              D.42883 = iargs[1];
              D.42883 = iargs[1];
              D.42883->sreg3 = -1;
              D.42890 = D.42883->sreg3;
              D.42883->sreg2 = D.42890;
              D.42891 = D.42883->sreg2;
              D.42883->sreg1 = D.42891;
              D.42883 = iargs[1];
              D.42811 = cfg->ip;
              D.42883->cil_code = D.42811;
              D.42883 = iargs[1];
              D.42802 = BIT_FIELD_REF <*cfg, 64, 5568>;
              D.42803 = D.42802 & 33554432;
              if (D.42803 != 0) goto <D.42957>; else goto <D.42958>;
              <D.42957>:
              iftmp.365 = vtable->klass;
              goto <D.42959>;
              <D.42958>:
              iftmp.365 = vtable;
              <D.42959>:
              D.42883->data.op[0].p = iftmp.365;
              D.42883 = iargs[1];
              D.42883->data.op[1].src = 14B;
              D.42883 = iargs[1];
              D.42883->type = 3;
              D.42883 = iargs[1];
              D.42960 = alloc_dreg (cfg, 3);
              D.42961 = (int) D.42960;
              D.42883->dreg = D.42961;
              D.42835 = cfg->cbb;
              D.42836 = D.42835->last_ins;
              if (D.42836 != 0B) goto <D.42962>; else goto <D.42963>;
              <D.42962>:
              D.42835 = cfg->cbb;
              D.42836 = D.42835->last_ins;
              D.42883 = iargs[1];
              D.42836->next = D.42883;
              D.42883 = iargs[1];
              D.42835 = cfg->cbb;
              D.42836 = D.42835->last_ins;
              D.42883->prev = D.42836;
              D.42835 = cfg->cbb;
              D.42883 = iargs[1];
              D.42835->last_ins = D.42883;
              goto <D.42964>;
              <D.42963>:
              D.42835 = cfg->cbb;
              D.42835 = cfg->cbb;
              D.42883 = iargs[1];
              D.42835->last_ins = D.42883;
              D.42836 = D.42835->last_ins;
              D.42835->code = D.42836;
              <D.42964>:
            }
            goto <D.42965>;
            <D.42938>:
            D.42804 = cfg->mempool;
            D.42966 = mono_mempool_alloc (D.42804, 80);
            iargs[0] = D.42966;
            D.42853 = iargs[0];
            D.42853 = iargs[0];
            D.42853->data.op[1].const_val = 0;
            D.42854 = D.42853->data.op[1].const_val;
            D.42853->data.op[0].const_val = D.42854;
            D.42853 = iargs[0];
            D.42853 = iargs[0];
            D.42853->prev = 0B;
            D.42855 = D.42853->prev;
            D.42853->next = D.42855;
            D.42853 = iargs[0];
            D.42802 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.42803 = D.42802 & 33554432;
            if (D.42803 != 0) goto <D.42968>; else goto <D.42969>;
            <D.42968>:
            iftmp.366 = 732;
            goto <D.42970>;
            <D.42969>:
            iftmp.366 = 363;
            <D.42970>:
            D.42853->opcode = iftmp.366;
            D.42853 = iargs[0];
            D.42853->flags = 0;
            D.42853 = iargs[0];
            D.42853->type = 0;
            D.42853 = iargs[0];
            D.42853->dreg = -1;
            D.42853 = iargs[0];
            D.42853 = iargs[0];
            D.42853 = iargs[0];
            D.42853->sreg3 = -1;
            D.42856 = D.42853->sreg3;
            D.42853->sreg2 = D.42856;
            D.42857 = D.42853->sreg2;
            D.42853->sreg1 = D.42857;
            D.42853 = iargs[0];
            D.42811 = cfg->ip;
            D.42853->cil_code = D.42811;
            D.42853 = iargs[0];
            D.42802 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.42803 = D.42802 & 33554432;
            if (D.42803 != 0) goto <D.42972>; else goto <D.42973>;
            <D.42972>:
            iftmp.367 = vtable->klass;
            goto <D.42974>;
            <D.42973>:
            iftmp.367 = vtable;
            <D.42974>:
            D.42853->data.op[0].p = iftmp.367;
            D.42853 = iargs[0];
            D.42853->data.op[1].src = 14B;
            D.42853 = iargs[0];
            D.42853->type = 3;
            D.42853 = iargs[0];
            D.42975 = alloc_dreg (cfg, 3);
            D.42976 = (int) D.42975;
            D.42853->dreg = D.42976;
            D.42835 = cfg->cbb;
            D.42836 = D.42835->last_ins;
            if (D.42836 != 0B) goto <D.42977>; else goto <D.42978>;
            <D.42977>:
            D.42835 = cfg->cbb;
            D.42836 = D.42835->last_ins;
            D.42853 = iargs[0];
            D.42836->next = D.42853;
            D.42853 = iargs[0];
            D.42835 = cfg->cbb;
            D.42836 = D.42835->last_ins;
            D.42853->prev = D.42836;
            D.42835 = cfg->cbb;
            D.42853 = iargs[0];
            D.42835->last_ins = D.42853;
            goto <D.42979>;
            <D.42978>:
            D.42835 = cfg->cbb;
            D.42835 = cfg->cbb;
            D.42853 = iargs[0];
            D.42835->last_ins = D.42853;
            D.42836 = D.42835->last_ins;
            D.42835->code = D.42836;
            <D.42979>:
            <D.42965>:
          }
        finally
          {
            pass_lw = {CLOBBER};
          }
      }
      <D.42897>:
      D.42845 = mono_emit_jit_icall (cfg, alloc_ftn, &iargs);
      return D.42845;
    }
  finally
    {
      iargs = {CLOBBER};
    }
}


mini_emit_inst_for_ctor (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, struct MonoInst * * args)
{
  struct MonoInst * D.42985;
  struct MonoInst * ins;

  ins = 0B;
  D.42985 = ins;
  return D.42985;
}


mono_method_check_inlining (struct MonoCompile * cfg, struct MonoMethod * method)
{
  struct MonoGenericSharingContext * D.42987;
  gboolean D.42990;
  unsigned int D.42991;
  int D.42994;
  short unsigned int D.42999;
  unsigned int D.43000;
  unsigned int D.43001;
  struct MonoClass * D.43003;
  long unsigned int D.43004;
  long unsigned int D.43005;
  int D.43007;
  int inline_limit_inited.368;
  const gchar * D.43011;
  const gchar * D.43014;
  int D.43015;
  unsigned int D.43017;
  int inline_limit.369;
  unsigned int inline_limit.370;
  int D.43022;
  int D.43023;
  unsigned int D.43026;
  unsigned int D.43027;
  struct MonoDomain * D.43032;
  long unsigned int D.43035;
  long unsigned int D.43036;
  int D.43039;
  unsigned int D.43043;
  unsigned int D.43044;
  long unsigned int D.43047;
  long unsigned int D.43050;
  struct MonoClassRuntimeInfo * D.43053;
  long unsigned int D.43058;
  long unsigned int D.43059;
  int D.43063;
  int D.43073;
  unsigned char D.43078;
  struct MonoMethodHeaderSummary header;
  struct MonoVTable * vtable;

  try
    {
      D.42987 = cfg->generic_sharing_context;
      if (D.42987 != 0B) goto <D.42988>; else goto <D.42989>;
      <D.42988>:
      D.42990 = 0;
      return D.42990;
      <D.42989>:
      D.42991 = cfg->inline_depth;
      if (D.42991 > 10) goto <D.42992>; else goto <D.42993>;
      <D.42992>:
      D.42990 = 0;
      return D.42990;
      <D.42993>:
      D.42994 = mono_method_get_header_summary (method, &header);
      if (D.42994 == 0) goto <D.42995>; else goto <D.42996>;
      <D.42995>:
      D.42990 = 0;
      return D.42990;
      <D.42996>:
      D.42999 = method->iflags;
      D.43000 = (unsigned int) D.42999;
      D.43001 = D.43000 & 40;
      if (D.43001 != 0) goto <D.42997>; else goto <D.43002>;
      <D.43002>:
      D.43003 = method->klass;
      D.43004 = BIT_FIELD_REF <*D.43003, 64, 256>;
      D.43005 = D.43004 & 2199023255552;
      if (D.43005 != 0) goto <D.42997>; else goto <D.43006>;
      <D.43006>:
      D.43007 = header.has_clauses;
      if (D.43007 != 0) goto <D.42997>; else goto <D.42998>;
      <D.42997>:
      D.42990 = 0;
      return D.42990;
      <D.42998>:
      inline_limit_inited.368 = inline_limit_inited;
      if (inline_limit_inited.368 == 0) goto <D.43009>; else goto <D.43010>;
      <D.43009>:
      D.43011 = monoeg_g_getenv ("MONO_INLINELIMIT");
      if (D.43011 != 0B) goto <D.43012>; else goto <D.43013>;
      <D.43012>:
      D.43014 = monoeg_g_getenv ("MONO_INLINELIMIT");
      D.43015 = atoi (D.43014);
      inline_limit = D.43015;
      goto <D.43016>;
      <D.43013>:
      inline_limit = 20;
      <D.43016>:
      inline_limit_inited = 1;
      <D.43010>:
      D.43017 = header.code_size;
      inline_limit.369 = inline_limit;
      inline_limit.370 = (unsigned int) inline_limit.369;
      if (D.43017 >= inline_limit.370) goto <D.43020>; else goto <D.43021>;
      <D.43020>:
      D.42999 = method->iflags;
      D.43022 = (int) D.42999;
      D.43023 = D.43022 & 256;
      if (D.43023 == 0) goto <D.43024>; else goto <D.43025>;
      <D.43024>:
      D.42990 = 0;
      return D.42990;
      <D.43025>:
      <D.43021>:
      D.43026 = cfg->opt;
      D.43027 = D.43026 & 512;
      if (D.43027 == 0) goto <D.43028>; else goto <D.43029>;
      <D.43028>:
      D.42999 = method->iflags;
      D.43022 = (int) D.42999;
      D.43023 = D.43022 & 256;
      if (D.43023 != 0) goto <D.43030>; else goto <D.43031>;
      <D.43030>:
      D.43032 = cfg->domain;
      D.43003 = method->klass;
      vtable = mono_class_vtable (D.43032, D.43003);
      if (vtable == 0B) goto <D.43033>; else goto <D.43034>;
      <D.43033>:
      D.42990 = 0;
      return D.42990;
      <D.43034>:
      D.43035 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.43036 = D.43035 & 33554432;
      if (D.43036 != 0) goto <D.43037>; else goto <D.43038>;
      <D.43037>:
      D.43003 = method->klass;
      D.43039 = mono_class_needs_cctor_run (D.43003, 0B);
      if (D.43039 != 0) goto <D.43040>; else goto <D.43041>;
      <D.43040>:
      D.42990 = 0;
      return D.42990;
      <D.43041>:
      <D.43038>:
      mono_runtime_class_init (vtable);
      goto <D.43042>;
      <D.43031>:
      D.43003 = method->klass;
      D.43043 = D.43003->flags;
      D.43044 = D.43043 & 1048576;
      if (D.43044 != 0) goto <D.43045>; else goto <D.43046>;
      <D.43045>:
      D.43035 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.43047 = D.43035 & 134217728;
      if (D.43047 != 0) goto <D.43048>; else goto <D.43049>;
      <D.43048>:
      D.43003 = method->klass;
      D.43004 = BIT_FIELD_REF <*D.43003, 64, 256>;
      D.43050 = D.43004 & 137438953472;
      if (D.43050 != 0) goto <D.43051>; else goto <D.43052>;
      <D.43051>:
      D.43003 = method->klass;
      D.43053 = D.43003->runtime_info;
      if (D.43053 == 0B) goto <D.43054>; else goto <D.43055>;
      <D.43054>:
      D.42990 = 0;
      return D.42990;
      <D.43055>:
      D.43032 = cfg->domain;
      D.43003 = method->klass;
      vtable = mono_class_vtable (D.43032, D.43003);
      if (vtable == 0B) goto <D.43056>; else goto <D.43057>;
      <D.43056>:
      D.42990 = 0;
      return D.42990;
      <D.43057>:
      D.43058 = BIT_FIELD_REF <*vtable, 64, 320>;
      D.43059 = D.43058 & 274877906944;
      if (D.43059 == 0) goto <D.43060>; else goto <D.43061>;
      <D.43060>:
      D.42990 = 0;
      return D.42990;
      <D.43061>:
      mono_runtime_class_init (vtable);
      <D.43052>:
      <D.43049>:
      goto <D.43062>;
      <D.43046>:
      D.43003 = method->klass;
      D.43063 = mono_class_needs_cctor_run (D.43003, 0B);
      if (D.43063 != 0) goto <D.43064>; else goto <D.43065>;
      <D.43064>:
      D.43003 = method->klass;
      D.43053 = D.43003->runtime_info;
      if (D.43053 == 0B) goto <D.43066>; else goto <D.43067>;
      <D.43066>:
      D.42990 = 0;
      return D.42990;
      <D.43067>:
      D.43032 = cfg->domain;
      D.43003 = method->klass;
      vtable = mono_class_vtable (D.43032, D.43003);
      if (vtable == 0B) goto <D.43068>; else goto <D.43069>;
      <D.43068>:
      D.42990 = 0;
      return D.42990;
      <D.43069>:
      D.43058 = BIT_FIELD_REF <*vtable, 64, 320>;
      D.43059 = D.43058 & 274877906944;
      if (D.43059 == 0) goto <D.43070>; else goto <D.43071>;
      <D.43070>:
      D.42990 = 0;
      return D.42990;
      <D.43071>:
      <D.43065>:
      <D.43062>:
      <D.43042>:
      goto <D.43072>;
      <D.43029>:
      D.43003 = method->klass;
      D.43073 = mono_class_needs_cctor_run (D.43003, 0B);
      if (D.43073 != 0) goto <D.43074>; else goto <D.43075>;
      <D.43074>:
      D.43003 = method->klass;
      D.43043 = D.43003->flags;
      D.43044 = D.43043 & 1048576;
      if (D.43044 == 0) goto <D.43076>; else goto <D.43077>;
      <D.43076>:
      D.42990 = 0;
      return D.42990;
      <D.43077>:
      <D.43075>:
      <D.43072>:
      D.43078 = mono_method_has_declsec (method);
      if (D.43078 != 0) goto <D.43079>; else goto <D.43080>;
      <D.43079>:
      D.42990 = 0;
      return D.42990;
      <D.43080>:
      D.42990 = 1;
      return D.42990;
    }
  finally
    {
      header = {CLOBBER};
    }
}


__attribute__((__gnu_inline__, __pure__, __leaf__, __nothrow__))
atoi (const char * __nptr)
{
  int D.43083;
  long int D.43084;

  D.43084 = strtol (__nptr, 0B, 10);
  D.43083 = (int) D.43084;
  return D.43083;
}


emit_get_rgctx_gsharedvt_call (struct MonoCompile * cfg, int context_used, struct MonoMethodSignature * sig, struct MonoMethod * cmethod, MonoRgctxInfoType rgctx_type)
{
  struct MonoMemPool * D.43086;
  struct MonoMethod * D.43087;
  int D.43088;
  struct MonoInst * D.43089;
  struct MonoJumpInfoGSharedVtCall * call_info;
  struct MonoJumpInfoRgctxEntry * entry;
  struct MonoInst * rgctx;

  D.43086 = cfg->mempool;
  call_info = mono_mempool_alloc0 (D.43086, 16);
  call_info->sig = sig;
  call_info->method = cmethod;
  D.43086 = cfg->mempool;
  D.43087 = cfg->current_method;
  D.43088 = context_used & 2;
  entry = mono_patch_info_rgctx_entry_new (D.43086, D.43087, D.43088, 45, call_info, rgctx_type);
  D.43087 = cfg->current_method;
  rgctx = emit_get_rgctx (cfg, D.43087, context_used);
  D.43089 = emit_rgctx_fetch (cfg, rgctx, entry);
  return D.43089;
}


save_cast_details (struct MonoCompile * cfg, struct MonoClass * klass, int obj_reg, gboolean null_check, struct MonoBasicBlock * * out_bblock)
{
  struct MonoDebugOptions * D.43091;
  int D.43092;
  unsigned int D.43095;
  unsigned int D.43096;
  unsigned int D.43097;
  struct MonoMemPool * D.43100;
  unsigned int D.43101;
  unsigned int D.43102;
  unsigned int D.43103;
  int D.43104;
  long int D.43105;
  struct MonoInst * D.43106;
  int D.43107;
  int D.43108;
  const unsigned char * D.43109;
  struct MonoBasicBlock * D.43110;
  struct MonoInst * D.43111;
  long int D.43115;
  struct MonoInst * D.43116;
  int D.43117;
  int D.43118;
  unsigned int D.43121;
  unsigned int D.43122;
  int D.43123;
  unsigned char * D.43127;
  struct MonoBasicBlock * * D.43130;
  long int D.43131;
  unsigned char * D.43132;
  long int D.43133;
  long int D.43134;
  long unsigned int D.43135;
  long unsigned int D.43136;
  struct MonoBasicBlock * * D.43137;
  unsigned int D.43138;
  short unsigned int D.43143;
  short unsigned int D.43144;
  short unsigned int D.43146;
  short unsigned int D.43148;
  struct MonoBasicBlock * * D.43149;
  struct MonoBasicBlock * * D.43150;
  struct MonoBasicBlock * D.43151;
  void * D.43161;
  struct MonoBasicBlock * * D.43162;
  struct MonoBasicBlock * * D.43163;
  long unsigned int D.43167;
  long unsigned int D.43168;
  unsigned int D.43171;
  unsigned int D.43172;
  int D.43173;
  struct _IO_FILE * stderr.371;
  long int D.43197;
  struct MonoInst * D.43198;
  int D.43199;
  int D.43200;
  long int D.43204;
  struct MonoInst * D.43205;
  int D.43206;
  int D.43207;
  long int D.43211;
  struct MonoInst * D.43212;
  int D.43213;
  int D.43214;
  int D.43215;
  long int D.43219;
  struct MonoInst * D.43220;
  int D.43221;
  int D.43222;
  long int D.43226;
  struct MonoInst * D.43227;
  int D.43228;
  int D.43229;
  unsigned char * D.43235;
  long int D.43238;
  long int D.43239;
  long unsigned int D.43240;
  long unsigned int D.43241;
  struct MonoBasicBlock * * D.43242;

  D.43091 = mini_get_debug_options ();
  D.43092 = D.43091->better_cast_details;
  if (D.43092 != 0) goto <D.43093>; else goto <D.43094>;
  <D.43093>:
  {
    int to_klass_reg;
    int vtable_reg;
    int klass_reg;
    struct MonoBasicBlock * is_null_bb;
    struct MonoInst * tls_get;

    D.43095 = alloc_preg (cfg);
    to_klass_reg = (int) D.43095;
    D.43096 = alloc_preg (cfg);
    vtable_reg = (int) D.43096;
    D.43097 = alloc_preg (cfg);
    klass_reg = (int) D.43097;
    is_null_bb = 0B;
    if (null_check != 0) goto <D.43098>; else goto <D.43099>;
    <D.43098>:
    D.43100 = cfg->mempool;
    is_null_bb = mono_mempool_alloc0 (D.43100, 296);
    D.43101 = cfg->num_bblocks;
    D.43102 = D.43101;
    D.43103 = D.43102 + 1;
    cfg->num_bblocks = D.43103;
    D.43104 = (int) D.43102;
    is_null_bb->block_num = D.43104;
    {
      struct MonoInst * inst;

      D.43100 = cfg->mempool;
      inst = mono_mempool_alloc (D.43100, 80);
      inst->data.op[1].const_val = 0;
      D.43105 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.43105;
      inst->prev = 0B;
      D.43106 = inst->prev;
      inst->next = D.43106;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.43107 = inst->sreg3;
      inst->sreg2 = D.43107;
      D.43108 = inst->sreg2;
      inst->sreg1 = D.43108;
      D.43109 = cfg->ip;
      inst->cil_code = D.43109;
      inst->dreg = -1;
      inst->sreg1 = obj_reg;
      inst->data.op[1].const_val = 0;
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      if (D.43111 != 0B) goto <D.43112>; else goto <D.43113>;
      <D.43112>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43111->next = inst;
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      inst->prev = D.43111;
      D.43110 = cfg->cbb;
      D.43110->last_ins = inst;
      goto <D.43114>;
      <D.43113>:
      D.43110 = cfg->cbb;
      D.43110 = cfg->cbb;
      D.43110->last_ins = inst;
      D.43111 = D.43110->last_ins;
      D.43110->code = D.43111;
      <D.43114>:
    }
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.43100 = cfg->mempool;
      ins = mono_mempool_alloc (D.43100, 80);
      ins->data.op[1].const_val = 0;
      D.43115 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.43115;
      ins->prev = 0B;
      D.43116 = ins->prev;
      ins->next = D.43116;
      ins->opcode = 551;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.43117 = ins->sreg3;
      ins->sreg2 = D.43117;
      D.43118 = ins->sreg2;
      ins->sreg1 = D.43118;
      D.43109 = cfg->ip;
      ins->cil_code = D.43109;
      if (0 != 0) goto <D.43119>; else goto <D.43120>;
      <D.43119>:
      D.43100 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.43100, 296);
      D.43101 = cfg->num_bblocks;
      D.43121 = D.43101;
      D.43122 = D.43121 + 1;
      cfg->num_bblocks = D.43122;
      D.43123 = (int) D.43121;
      falsebb->block_num = D.43123;
      ins->data.op[0].target_block = is_null_bb;
      D.43110 = cfg->cbb;
      mono_link_bblock (cfg, D.43110, is_null_bb);
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      if (D.43111 != 0B) goto <D.43124>; else goto <D.43125>;
      <D.43124>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43111->next = ins;
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      ins->prev = D.43111;
      D.43110 = cfg->cbb;
      D.43110->last_ins = ins;
      goto <D.43126>;
      <D.43125>:
      D.43110 = cfg->cbb;
      D.43110 = cfg->cbb;
      D.43110->last_ins = ins;
      D.43111 = D.43110->last_ins;
      D.43110->code = D.43111;
      <D.43126>:
      D.43127 = falsebb->cil_code;
      if (D.43127 != 0B) goto <D.43128>; else goto <D.43129>;
      <D.43128>:
      D.43130 = cfg->cil_offset_to_bb;
      D.43127 = falsebb->cil_code;
      D.43131 = (long int) D.43127;
      D.43132 = cfg->cil_start;
      D.43133 = (long int) D.43132;
      D.43134 = D.43131 - D.43133;
      D.43135 = (long unsigned int) D.43134;
      D.43136 = D.43135 * 8;
      D.43137 = D.43130 + D.43136;
      *D.43137 = falsebb;
      <D.43129>:
      D.43138 = cfg->real_offset;
      falsebb->real_offset = D.43138;
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      if (D.43111 != 0B) goto <D.43142>; else goto <D.43139>;
      <D.43142>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43143 = D.43111->opcode;
      D.43144 = D.43143 + 64985;
      if (D.43144 <= 9) goto <D.43140>; else goto <D.43145>;
      <D.43145>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43143 = D.43111->opcode;
      D.43146 = D.43143 + 64878;
      if (D.43146 <= 9) goto <D.43140>; else goto <D.43147>;
      <D.43147>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43143 = D.43111->opcode;
      D.43148 = D.43143 + 64888;
      if (D.43148 <= 9) goto <D.43140>; else goto <D.43139>;
      <D.43140>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43149 = D.43111->data.op[1].many_blocks;
      D.43150 = D.43149 + 8;
      D.43151 = *D.43150;
      if (D.43151 == 0B) goto <D.43152>; else goto <D.43139>;
      <D.43152>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43149 = D.43111->data.op[1].many_blocks;
      D.43150 = D.43149 + 8;
      *D.43150 = falsebb;
      D.43110 = cfg->cbb;
      mono_link_bblock (cfg, D.43110, falsebb);
      goto <D.43141>;
      <D.43139>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      if (D.43111 == 0B) goto <D.43153>; else goto <D.43155>;
      <D.43155>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43143 = D.43111->opcode;
      if (D.43143 != 442) goto <D.43156>; else goto <D.43154>;
      <D.43156>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43143 = D.43111->opcode;
      if (D.43143 != 759) goto <D.43157>; else goto <D.43154>;
      <D.43157>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43143 = D.43111->opcode;
      D.43144 = D.43143 + 64985;
      if (D.43144 > 9) goto <D.43158>; else goto <D.43154>;
      <D.43158>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43143 = D.43111->opcode;
      D.43146 = D.43143 + 64878;
      if (D.43146 > 9) goto <D.43159>; else goto <D.43154>;
      <D.43159>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43143 = D.43111->opcode;
      D.43148 = D.43143 + 64888;
      if (D.43148 > 9) goto <D.43153>; else goto <D.43154>;
      <D.43153>:
      D.43110 = cfg->cbb;
      mono_link_bblock (cfg, D.43110, falsebb);
      <D.43154>:
      <D.43141>:
      D.43110 = cfg->cbb;
      D.43110->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.43160>;
      <D.43120>:
      D.43100 = cfg->mempool;
      D.43161 = mono_mempool_alloc (D.43100, 16);
      ins->data.op[1].many_blocks = D.43161;
      D.43162 = ins->data.op[1].many_blocks;
      *D.43162 = is_null_bb;
      D.43162 = ins->data.op[1].many_blocks;
      D.43163 = D.43162 + 8;
      *D.43163 = 0B;
      D.43110 = cfg->cbb;
      mono_link_bblock (cfg, D.43110, is_null_bb);
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      if (D.43111 != 0B) goto <D.43164>; else goto <D.43165>;
      <D.43164>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43111->next = ins;
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      ins->prev = D.43111;
      D.43110 = cfg->cbb;
      D.43110->last_ins = ins;
      goto <D.43166>;
      <D.43165>:
      D.43110 = cfg->cbb;
      D.43110 = cfg->cbb;
      D.43110->last_ins = ins;
      D.43111 = D.43110->last_ins;
      D.43110->code = D.43111;
      <D.43166>:
      D.43167 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.43168 = D.43167 & 268435456;
      if (D.43168 == 0) goto <D.43169>; else goto <D.43170>;
      <D.43169>:
      D.43100 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.43100, 296);
      D.43101 = cfg->num_bblocks;
      D.43171 = D.43101;
      D.43172 = D.43171 + 1;
      cfg->num_bblocks = D.43172;
      D.43173 = (int) D.43171;
      falsebb->block_num = D.43173;
      D.43162 = ins->data.op[1].many_blocks;
      D.43163 = D.43162 + 8;
      *D.43163 = falsebb;
      D.43110 = cfg->cbb;
      mono_link_bblock (cfg, D.43110, falsebb);
      D.43127 = falsebb->cil_code;
      if (D.43127 != 0B) goto <D.43174>; else goto <D.43175>;
      <D.43174>:
      D.43130 = cfg->cil_offset_to_bb;
      D.43127 = falsebb->cil_code;
      D.43131 = (long int) D.43127;
      D.43132 = cfg->cil_start;
      D.43133 = (long int) D.43132;
      D.43134 = D.43131 - D.43133;
      D.43135 = (long unsigned int) D.43134;
      D.43136 = D.43135 * 8;
      D.43137 = D.43130 + D.43136;
      *D.43137 = falsebb;
      <D.43175>:
      D.43138 = cfg->real_offset;
      falsebb->real_offset = D.43138;
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      if (D.43111 != 0B) goto <D.43179>; else goto <D.43176>;
      <D.43179>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43143 = D.43111->opcode;
      D.43144 = D.43143 + 64985;
      if (D.43144 <= 9) goto <D.43177>; else goto <D.43180>;
      <D.43180>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43143 = D.43111->opcode;
      D.43146 = D.43143 + 64878;
      if (D.43146 <= 9) goto <D.43177>; else goto <D.43181>;
      <D.43181>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43143 = D.43111->opcode;
      D.43148 = D.43143 + 64888;
      if (D.43148 <= 9) goto <D.43177>; else goto <D.43176>;
      <D.43177>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43149 = D.43111->data.op[1].many_blocks;
      D.43150 = D.43149 + 8;
      D.43151 = *D.43150;
      if (D.43151 == 0B) goto <D.43182>; else goto <D.43176>;
      <D.43182>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43149 = D.43111->data.op[1].many_blocks;
      D.43150 = D.43149 + 8;
      *D.43150 = falsebb;
      D.43110 = cfg->cbb;
      mono_link_bblock (cfg, D.43110, falsebb);
      goto <D.43178>;
      <D.43176>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      if (D.43111 == 0B) goto <D.43183>; else goto <D.43185>;
      <D.43185>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43143 = D.43111->opcode;
      if (D.43143 != 442) goto <D.43186>; else goto <D.43184>;
      <D.43186>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43143 = D.43111->opcode;
      if (D.43143 != 759) goto <D.43187>; else goto <D.43184>;
      <D.43187>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43143 = D.43111->opcode;
      D.43144 = D.43143 + 64985;
      if (D.43144 > 9) goto <D.43188>; else goto <D.43184>;
      <D.43188>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43143 = D.43111->opcode;
      D.43146 = D.43143 + 64878;
      if (D.43146 > 9) goto <D.43189>; else goto <D.43184>;
      <D.43189>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43143 = D.43111->opcode;
      D.43148 = D.43143 + 64888;
      if (D.43148 > 9) goto <D.43183>; else goto <D.43184>;
      <D.43183>:
      D.43110 = cfg->cbb;
      mono_link_bblock (cfg, D.43110, falsebb);
      <D.43184>:
      <D.43178>:
      D.43110 = cfg->cbb;
      D.43110->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.43190>;
      <D.43170>:
      D.43110 = cfg->cbb;
      D.43110->extended = 1;
      <D.43190>:
      <D.43160>:
    }
    <D.43099>:
    tls_get = mono_get_jit_tls_intrinsic (cfg);
    if (tls_get == 0B) goto <D.43191>; else goto <D.43192>;
    <D.43191>:
    stderr.371 = stderr;
    fprintf (stderr.371, "error: --debug=casts not supported on this platform.\n.");
    exit (1);
    <D.43192>:
    D.43110 = cfg->cbb;
    D.43111 = D.43110->last_ins;
    if (D.43111 != 0B) goto <D.43194>; else goto <D.43195>;
    <D.43194>:
    D.43110 = cfg->cbb;
    D.43111 = D.43110->last_ins;
    D.43111->next = tls_get;
    D.43110 = cfg->cbb;
    D.43111 = D.43110->last_ins;
    tls_get->prev = D.43111;
    D.43110 = cfg->cbb;
    D.43110->last_ins = tls_get;
    goto <D.43196>;
    <D.43195>:
    D.43110 = cfg->cbb;
    D.43110 = cfg->cbb;
    D.43110->last_ins = tls_get;
    D.43111 = D.43110->last_ins;
    D.43110->code = D.43111;
    <D.43196>:
    {
      struct MonoInst * inst;

      D.43100 = cfg->mempool;
      inst = mono_mempool_alloc (D.43100, 80);
      inst->data.op[1].const_val = 0;
      D.43197 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.43197;
      inst->prev = 0B;
      D.43198 = inst->prev;
      inst->next = D.43198;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.43199 = inst->sreg3;
      inst->sreg2 = D.43199;
      D.43200 = inst->sreg2;
      inst->sreg1 = D.43200;
      D.43109 = cfg->ip;
      inst->cil_code = D.43109;
      inst->dreg = vtable_reg;
      inst->sreg1 = obj_reg;
      inst->data.op[0].const_val = 0;
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      if (D.43111 != 0B) goto <D.43201>; else goto <D.43202>;
      <D.43201>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43111->next = inst;
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      inst->prev = D.43111;
      D.43110 = cfg->cbb;
      D.43110->last_ins = inst;
      goto <D.43203>;
      <D.43202>:
      D.43110 = cfg->cbb;
      D.43110 = cfg->cbb;
      D.43110->last_ins = inst;
      D.43111 = D.43110->last_ins;
      D.43110->code = D.43111;
      <D.43203>:
    }
    {
      struct MonoInst * inst;

      D.43100 = cfg->mempool;
      inst = mono_mempool_alloc (D.43100, 80);
      inst->data.op[1].const_val = 0;
      D.43204 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.43204;
      inst->prev = 0B;
      D.43205 = inst->prev;
      inst->next = D.43205;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.43206 = inst->sreg3;
      inst->sreg2 = D.43206;
      D.43207 = inst->sreg2;
      inst->sreg1 = D.43207;
      D.43109 = cfg->ip;
      inst->cil_code = D.43109;
      inst->dreg = klass_reg;
      inst->sreg1 = vtable_reg;
      inst->data.op[0].const_val = 0;
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      if (D.43111 != 0B) goto <D.43208>; else goto <D.43209>;
      <D.43208>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43111->next = inst;
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      inst->prev = D.43111;
      D.43110 = cfg->cbb;
      D.43110->last_ins = inst;
      goto <D.43210>;
      <D.43209>:
      D.43110 = cfg->cbb;
      D.43110 = cfg->cbb;
      D.43110->last_ins = inst;
      D.43111 = D.43110->last_ins;
      D.43110->code = D.43111;
      <D.43210>:
    }
    {
      struct MonoInst * inst;

      D.43100 = cfg->mempool;
      inst = mono_mempool_alloc (D.43100, 80);
      inst->data.op[1].const_val = 0;
      D.43211 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.43211;
      inst->prev = 0B;
      D.43212 = inst->prev;
      inst->next = D.43212;
      inst->opcode = 374;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.43213 = inst->sreg3;
      inst->sreg2 = D.43213;
      D.43214 = inst->sreg2;
      inst->sreg1 = D.43214;
      D.43109 = cfg->ip;
      inst->cil_code = D.43109;
      inst->sreg1 = klass_reg;
      D.43215 = tls_get->dreg;
      inst->dreg = D.43215;
      inst->data.op[0].const_val = 80;
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      if (D.43111 != 0B) goto <D.43216>; else goto <D.43217>;
      <D.43216>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43111->next = inst;
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      inst->prev = D.43111;
      D.43110 = cfg->cbb;
      D.43110->last_ins = inst;
      goto <D.43218>;
      <D.43217>:
      D.43110 = cfg->cbb;
      D.43110 = cfg->cbb;
      D.43110->last_ins = inst;
      D.43111 = D.43110->last_ins;
      D.43110->code = D.43111;
      <D.43218>:
    }
    {
      struct MonoInst * inst;

      D.43100 = cfg->mempool;
      inst = mono_mempool_alloc (D.43100, 80);
      inst->data.op[1].const_val = 0;
      D.43219 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.43219;
      inst->prev = 0B;
      D.43220 = inst->prev;
      inst->next = D.43220;
      inst->opcode = 363;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.43221 = inst->sreg3;
      inst->sreg2 = D.43221;
      D.43222 = inst->sreg2;
      inst->sreg1 = D.43222;
      D.43109 = cfg->ip;
      inst->cil_code = D.43109;
      inst->dreg = to_klass_reg;
      inst->data.op[0].p = klass;
      inst->type = 3;
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      if (D.43111 != 0B) goto <D.43223>; else goto <D.43224>;
      <D.43223>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43111->next = inst;
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      inst->prev = D.43111;
      D.43110 = cfg->cbb;
      D.43110->last_ins = inst;
      goto <D.43225>;
      <D.43224>:
      D.43110 = cfg->cbb;
      D.43110 = cfg->cbb;
      D.43110->last_ins = inst;
      D.43111 = D.43110->last_ins;
      D.43110->code = D.43111;
      <D.43225>:
    }
    {
      struct MonoInst * inst;

      D.43100 = cfg->mempool;
      inst = mono_mempool_alloc (D.43100, 80);
      inst->data.op[1].const_val = 0;
      D.43226 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.43226;
      inst->prev = 0B;
      D.43227 = inst->prev;
      inst->next = D.43227;
      inst->opcode = 374;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.43228 = inst->sreg3;
      inst->sreg2 = D.43228;
      D.43229 = inst->sreg2;
      inst->sreg1 = D.43229;
      D.43109 = cfg->ip;
      inst->cil_code = D.43109;
      inst->sreg1 = to_klass_reg;
      D.43215 = tls_get->dreg;
      inst->dreg = D.43215;
      inst->data.op[0].const_val = 88;
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      if (D.43111 != 0B) goto <D.43230>; else goto <D.43231>;
      <D.43230>:
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      D.43111->next = inst;
      D.43110 = cfg->cbb;
      D.43111 = D.43110->last_ins;
      inst->prev = D.43111;
      D.43110 = cfg->cbb;
      D.43110->last_ins = inst;
      goto <D.43232>;
      <D.43231>:
      D.43110 = cfg->cbb;
      D.43110 = cfg->cbb;
      D.43110->last_ins = inst;
      D.43111 = D.43110->last_ins;
      D.43110->code = D.43111;
      <D.43232>:
    }
    if (null_check != 0) goto <D.43233>; else goto <D.43234>;
    <D.43233>:
    D.43235 = is_null_bb->cil_code;
    if (D.43235 != 0B) goto <D.43236>; else goto <D.43237>;
    <D.43236>:
    D.43130 = cfg->cil_offset_to_bb;
    D.43235 = is_null_bb->cil_code;
    D.43238 = (long int) D.43235;
    D.43132 = cfg->cil_start;
    D.43133 = (long int) D.43132;
    D.43239 = D.43238 - D.43133;
    D.43240 = (long unsigned int) D.43239;
    D.43241 = D.43240 * 8;
    D.43242 = D.43130 + D.43241;
    *D.43242 = is_null_bb;
    <D.43237>:
    D.43138 = cfg->real_offset;
    is_null_bb->real_offset = D.43138;
    D.43110 = cfg->cbb;
    D.43111 = D.43110->last_ins;
    if (D.43111 != 0B) goto <D.43246>; else goto <D.43243>;
    <D.43246>:
    D.43110 = cfg->cbb;
    D.43111 = D.43110->last_ins;
    D.43143 = D.43111->opcode;
    D.43144 = D.43143 + 64985;
    if (D.43144 <= 9) goto <D.43244>; else goto <D.43247>;
    <D.43247>:
    D.43110 = cfg->cbb;
    D.43111 = D.43110->last_ins;
    D.43143 = D.43111->opcode;
    D.43146 = D.43143 + 64878;
    if (D.43146 <= 9) goto <D.43244>; else goto <D.43248>;
    <D.43248>:
    D.43110 = cfg->cbb;
    D.43111 = D.43110->last_ins;
    D.43143 = D.43111->opcode;
    D.43148 = D.43143 + 64888;
    if (D.43148 <= 9) goto <D.43244>; else goto <D.43243>;
    <D.43244>:
    D.43110 = cfg->cbb;
    D.43111 = D.43110->last_ins;
    D.43149 = D.43111->data.op[1].many_blocks;
    D.43150 = D.43149 + 8;
    D.43151 = *D.43150;
    if (D.43151 == 0B) goto <D.43249>; else goto <D.43243>;
    <D.43249>:
    D.43110 = cfg->cbb;
    D.43111 = D.43110->last_ins;
    D.43149 = D.43111->data.op[1].many_blocks;
    D.43150 = D.43149 + 8;
    *D.43150 = is_null_bb;
    D.43110 = cfg->cbb;
    mono_link_bblock (cfg, D.43110, is_null_bb);
    goto <D.43245>;
    <D.43243>:
    D.43110 = cfg->cbb;
    D.43111 = D.43110->last_ins;
    if (D.43111 == 0B) goto <D.43250>; else goto <D.43252>;
    <D.43252>:
    D.43110 = cfg->cbb;
    D.43111 = D.43110->last_ins;
    D.43143 = D.43111->opcode;
    if (D.43143 != 442) goto <D.43253>; else goto <D.43251>;
    <D.43253>:
    D.43110 = cfg->cbb;
    D.43111 = D.43110->last_ins;
    D.43143 = D.43111->opcode;
    if (D.43143 != 759) goto <D.43254>; else goto <D.43251>;
    <D.43254>:
    D.43110 = cfg->cbb;
    D.43111 = D.43110->last_ins;
    D.43143 = D.43111->opcode;
    D.43144 = D.43143 + 64985;
    if (D.43144 > 9) goto <D.43255>; else goto <D.43251>;
    <D.43255>:
    D.43110 = cfg->cbb;
    D.43111 = D.43110->last_ins;
    D.43143 = D.43111->opcode;
    D.43146 = D.43143 + 64878;
    if (D.43146 > 9) goto <D.43256>; else goto <D.43251>;
    <D.43256>:
    D.43110 = cfg->cbb;
    D.43111 = D.43110->last_ins;
    D.43143 = D.43111->opcode;
    D.43148 = D.43143 + 64888;
    if (D.43148 > 9) goto <D.43250>; else goto <D.43251>;
    <D.43250>:
    D.43110 = cfg->cbb;
    mono_link_bblock (cfg, D.43110, is_null_bb);
    <D.43251>:
    <D.43245>:
    D.43110 = cfg->cbb;
    D.43110->next_bb = is_null_bb;
    cfg->cbb = is_null_bb;
    if (out_bblock != 0B) goto <D.43257>; else goto <D.43258>;
    <D.43257>:
    D.43110 = cfg->cbb;
    *out_bblock = D.43110;
    <D.43258>:
    <D.43234>:
  }
  <D.43094>:
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.43259;

  D.43259 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.43259;
}


reset_cast_details (struct MonoCompile * cfg)
{
  struct MonoDebugOptions * D.43261;
  int D.43262;
  struct MonoBasicBlock * D.43265;
  struct MonoInst * D.43266;
  struct MonoMemPool * D.43270;
  long int D.43271;
  struct MonoInst * D.43272;
  int D.43273;
  int D.43274;
  const unsigned char * D.43275;
  int D.43276;

  D.43261 = mini_get_debug_options ();
  D.43262 = D.43261->better_cast_details;
  if (D.43262 != 0) goto <D.43263>; else goto <D.43264>;
  <D.43263>:
  {
    struct MonoInst * tls_get;

    tls_get = mono_get_jit_tls_intrinsic (cfg);
    D.43265 = cfg->cbb;
    D.43266 = D.43265->last_ins;
    if (D.43266 != 0B) goto <D.43267>; else goto <D.43268>;
    <D.43267>:
    D.43265 = cfg->cbb;
    D.43266 = D.43265->last_ins;
    D.43266->next = tls_get;
    D.43265 = cfg->cbb;
    D.43266 = D.43265->last_ins;
    tls_get->prev = D.43266;
    D.43265 = cfg->cbb;
    D.43265->last_ins = tls_get;
    goto <D.43269>;
    <D.43268>:
    D.43265 = cfg->cbb;
    D.43265 = cfg->cbb;
    D.43265->last_ins = tls_get;
    D.43266 = D.43265->last_ins;
    D.43265->code = D.43266;
    <D.43269>:
    {
      struct MonoInst * inst;

      D.43270 = cfg->mempool;
      inst = mono_mempool_alloc (D.43270, 80);
      inst->data.op[1].const_val = 0;
      D.43271 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.43271;
      inst->prev = 0B;
      D.43272 = inst->prev;
      inst->next = D.43272;
      inst->opcode = 381;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.43273 = inst->sreg3;
      inst->sreg2 = D.43273;
      D.43274 = inst->sreg2;
      inst->sreg1 = D.43274;
      D.43275 = cfg->ip;
      inst->cil_code = D.43275;
      D.43276 = tls_get->dreg;
      inst->dreg = D.43276;
      inst->data.op[0].const_val = 80;
      inst->data.op[1].const_val = 0;
      D.43265 = cfg->cbb;
      D.43266 = D.43265->last_ins;
      if (D.43266 != 0B) goto <D.43277>; else goto <D.43278>;
      <D.43277>:
      D.43265 = cfg->cbb;
      D.43266 = D.43265->last_ins;
      D.43266->next = inst;
      D.43265 = cfg->cbb;
      D.43266 = D.43265->last_ins;
      inst->prev = D.43266;
      D.43265 = cfg->cbb;
      D.43265->last_ins = inst;
      goto <D.43279>;
      <D.43278>:
      D.43265 = cfg->cbb;
      D.43265 = cfg->cbb;
      D.43265->last_ins = inst;
      D.43266 = D.43265->last_ins;
      D.43265->code = D.43266;
      <D.43279>:
    }
  }
  <D.43264>:
}


handle_isinst (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * src, int context_used)
{
  unsigned int D.43280;
  unsigned int D.43281;
  struct MonoMemPool * D.43286;
  void * D.43287;
  struct MonoInst * D.43288;
  long int D.43289;
  struct MonoInst * D.43290;
  int D.43291;
  int D.43292;
  const unsigned char * D.43293;
  unsigned int D.43294;
  int D.43295;
  int D.43296;
  struct MonoBasicBlock * D.43297;
  struct MonoInst * D.43298;
  struct MonoInst * D.43302;
  unsigned int D.43303;
  unsigned int D.43304;
  unsigned int D.43305;
  int D.43306;
  unsigned int D.43307;
  unsigned int D.43308;
  int D.43309;
  unsigned int D.43310;
  unsigned int D.43311;
  int D.43312;
  long int D.43313;
  struct MonoInst * D.43314;
  int D.43315;
  int D.43316;
  long int D.43320;
  struct MonoInst * D.43321;
  int D.43322;
  int D.43323;
  long int D.43327;
  struct MonoInst * D.43328;
  int D.43329;
  int D.43330;
  unsigned int D.43333;
  unsigned int D.43334;
  int D.43335;
  unsigned char * D.43339;
  struct MonoBasicBlock * * D.43342;
  long int D.43343;
  unsigned char * D.43344;
  long int D.43345;
  long int D.43346;
  long unsigned int D.43347;
  long unsigned int D.43348;
  struct MonoBasicBlock * * D.43349;
  unsigned int D.43350;
  short unsigned int D.43355;
  short unsigned int D.43356;
  short unsigned int D.43358;
  short unsigned int D.43360;
  struct MonoBasicBlock * * D.43361;
  struct MonoBasicBlock * * D.43362;
  struct MonoBasicBlock * D.43363;
  void * D.43373;
  struct MonoBasicBlock * * D.43374;
  struct MonoBasicBlock * * D.43375;
  long unsigned int D.43379;
  long unsigned int D.43380;
  unsigned int D.43383;
  unsigned int D.43384;
  int D.43385;
  long int D.43403;
  struct MonoInst * D.43404;
  int D.43405;
  int D.43406;
  unsigned int D.43410;
  unsigned int D.43411;
  _Bool D.43414;
  long int D.43415;
  long int D.43416;
  unsigned int D.43420;
  unsigned char D.43421;
  unsigned int D.43424;
  unsigned int D.43425;
  long int D.43428;
  struct MonoInst * D.43429;
  int D.43430;
  int D.43431;
  long int D.43435;
  struct MonoInst * D.43436;
  int D.43437;
  int D.43438;
  long int D.43439;
  long int D.43443;
  struct MonoInst * D.43444;
  int D.43445;
  int D.43446;
  unsigned int D.43449;
  unsigned int D.43450;
  int D.43451;
  unsigned char * D.43455;
  long int D.43458;
  long int D.43459;
  long unsigned int D.43460;
  long unsigned int D.43461;
  struct MonoBasicBlock * * D.43462;
  void * D.43478;
  struct MonoBasicBlock * * D.43479;
  struct MonoBasicBlock * * D.43480;
  unsigned int D.43486;
  unsigned int D.43487;
  int D.43488;
  long int D.43506;
  struct MonoInst * D.43507;
  int D.43508;
  int D.43509;
  long int D.43513;
  struct MonoInst * D.43514;
  int D.43515;
  int D.43516;
  struct MonoClass * D.43520;
  struct MonoClass * D.43521;
  unsigned int D.43524;
  long int D.43525;
  struct MonoInst * D.43526;
  int D.43527;
  int D.43528;
  struct MonoClass * D.43532;
  struct MonoClass * D.43533;
  long int D.43534;
  struct MonoInst * D.43535;
  int D.43536;
  int D.43537;
  unsigned int D.43540;
  unsigned int D.43541;
  int D.43542;
  unsigned char * D.43546;
  long int D.43549;
  long int D.43550;
  long unsigned int D.43551;
  long unsigned int D.43552;
  struct MonoBasicBlock * * D.43553;
  void * D.43569;
  struct MonoBasicBlock * * D.43570;
  struct MonoBasicBlock * * D.43571;
  unsigned int D.43577;
  unsigned int D.43578;
  int D.43579;
  long int D.43600;
  struct MonoInst * D.43601;
  int D.43602;
  int D.43603;
  unsigned int D.43606;
  unsigned int D.43607;
  int D.43608;
  unsigned char * D.43612;
  long int D.43615;
  long int D.43616;
  long unsigned int D.43617;
  long unsigned int D.43618;
  struct MonoBasicBlock * * D.43619;
  void * D.43635;
  struct MonoBasicBlock * * D.43636;
  struct MonoBasicBlock * * D.43637;
  unsigned int D.43643;
  unsigned int D.43644;
  int D.43645;
  long int D.43666;
  struct MonoInst * D.43667;
  int D.43668;
  int D.43669;
  unsigned int D.43672;
  unsigned int D.43673;
  int D.43674;
  unsigned char * D.43678;
  long int D.43681;
  long int D.43682;
  long unsigned int D.43683;
  long unsigned int D.43684;
  struct MonoBasicBlock * * D.43685;
  void * D.43701;
  struct MonoBasicBlock * * D.43702;
  struct MonoBasicBlock * * D.43703;
  unsigned int D.43709;
  unsigned int D.43710;
  int D.43711;
  unsigned int D.43730;
  unsigned int D.43731;
  unsigned char D.43737;
  unsigned int D.43740;
  long int D.43741;
  struct MonoInst * D.43742;
  int D.43743;
  int D.43744;
  long int D.43748;
  struct MonoInst * D.43749;
  int D.43750;
  int D.43751;
  long int D.43755;
  struct MonoInst * D.43756;
  int D.43757;
  int D.43758;
  unsigned int D.43761;
  unsigned int D.43762;
  int D.43763;
  unsigned char * D.43767;
  long int D.43770;
  long int D.43771;
  long unsigned int D.43772;
  long unsigned int D.43773;
  struct MonoBasicBlock * * D.43774;
  void * D.43790;
  struct MonoBasicBlock * * D.43791;
  struct MonoBasicBlock * * D.43792;
  unsigned int D.43798;
  unsigned int D.43799;
  int D.43800;
  int D.43819;
  long int D.43824;
  struct MonoInst * D.43825;
  int D.43826;
  int D.43827;
  long unsigned int D.43834;
  unsigned int D.43836;
  unsigned int D.43837;
  unsigned int D.43839;
  struct MonoDomain * D.43845;
  long int D.43848;
  struct MonoInst * D.43849;
  int D.43850;
  int D.43851;
  long int vt.372;
  long int D.43857;
  struct MonoInst * D.43858;
  int D.43859;
  int D.43860;
  long int D.43864;
  struct MonoInst * D.43865;
  int D.43866;
  int D.43867;
  long int klass.373;
  long int D.43872;
  struct MonoInst * D.43873;
  int D.43874;
  int D.43875;
  unsigned int D.43878;
  unsigned int D.43879;
  int D.43880;
  unsigned char * D.43884;
  long int D.43887;
  long int D.43888;
  long unsigned int D.43889;
  long unsigned int D.43890;
  struct MonoBasicBlock * * D.43891;
  void * D.43907;
  struct MonoBasicBlock * * D.43908;
  struct MonoBasicBlock * * D.43909;
  unsigned int D.43915;
  unsigned int D.43916;
  int D.43917;
  long int D.43935;
  struct MonoInst * D.43936;
  int D.43937;
  int D.43938;
  unsigned int D.43941;
  unsigned int D.43942;
  int D.43943;
  unsigned char * D.43947;
  long int D.43950;
  long int D.43951;
  long unsigned int D.43952;
  long unsigned int D.43953;
  struct MonoBasicBlock * * D.43954;
  void * D.43970;
  struct MonoBasicBlock * * D.43971;
  struct MonoBasicBlock * * D.43972;
  unsigned int D.43978;
  unsigned int D.43979;
  int D.43980;
  long int D.43998;
  struct MonoInst * D.43999;
  int D.44000;
  int D.44001;
  unsigned char * D.44005;
  long int D.44008;
  long int D.44009;
  long unsigned int D.44010;
  long unsigned int D.44011;
  struct MonoBasicBlock * * D.44012;
  long int D.44027;
  struct MonoInst * D.44028;
  int D.44029;
  int D.44030;
  long int D.44034;
  struct MonoInst * D.44035;
  int D.44036;
  int D.44037;
  unsigned int D.44040;
  unsigned int D.44041;
  int D.44042;
  unsigned char * D.44046;
  long int D.44049;
  long int D.44050;
  long unsigned int D.44051;
  long unsigned int D.44052;
  struct MonoBasicBlock * * D.44053;
  void * D.44069;
  struct MonoBasicBlock * * D.44070;
  struct MonoBasicBlock * * D.44071;
  unsigned int D.44077;
  unsigned int D.44078;
  int D.44079;
  unsigned char * D.44097;
  long int D.44100;
  long int D.44101;
  long unsigned int D.44102;
  long unsigned int D.44103;
  struct MonoBasicBlock * * D.44104;
  unsigned char * D.44119;
  long int D.44122;
  long int D.44123;
  long unsigned int D.44124;
  long unsigned int D.44125;
  struct MonoBasicBlock * * D.44126;
  struct MonoInst * ins;
  struct MonoBasicBlock * is_null_bb;
  struct MonoBasicBlock * false_bb;
  struct MonoBasicBlock * end_bb;
  int obj_reg;
  int vtable_reg;
  int res_reg;
  struct MonoInst * klass_inst;

  obj_reg = src->dreg;
  D.43280 = alloc_preg (cfg);
  vtable_reg = (int) D.43280;
  D.43281 = alloc_ireg_ref (cfg);
  res_reg = (int) D.43281;
  klass_inst = 0B;
  if (context_used != 0) goto <D.43282>; else goto <D.43283>;
  <D.43282>:
  {
    struct MonoInst * args[3];

    try
      {
        mini_class_has_reference_variant_generic_argument (cfg, klass, context_used);
        if (1 != 0) goto <D.43284>; else goto <D.43285>;
        <D.43284>:
        {
          struct MonoMethod * mono_isinst;
          struct MonoInst * cache_ins;

          mono_isinst = mono_marshal_get_isinst_with_cache ();
          cache_ins = emit_get_rgctx_klass (cfg, context_used, klass, 12);
          args[0] = src;
          D.43286 = cfg->mempool;
          D.43287 = mono_mempool_alloc (D.43286, 80);
          args[1] = D.43287;
          D.43288 = args[1];
          D.43288 = args[1];
          D.43288->data.op[1].const_val = 0;
          D.43289 = D.43288->data.op[1].const_val;
          D.43288->data.op[0].const_val = D.43289;
          D.43288 = args[1];
          D.43288 = args[1];
          D.43288->prev = 0B;
          D.43290 = D.43288->prev;
          D.43288->next = D.43290;
          D.43288 = args[1];
          D.43288->opcode = 388;
          D.43288 = args[1];
          D.43288->flags = 0;
          D.43288 = args[1];
          D.43288->type = 0;
          D.43288 = args[1];
          D.43288->dreg = -1;
          D.43288 = args[1];
          D.43288 = args[1];
          D.43288 = args[1];
          D.43288->sreg3 = -1;
          D.43291 = D.43288->sreg3;
          D.43288->sreg2 = D.43291;
          D.43292 = D.43288->sreg2;
          D.43288->sreg1 = D.43292;
          D.43288 = args[1];
          D.43293 = cfg->ip;
          D.43288->cil_code = D.43293;
          D.43288 = args[1];
          D.43294 = alloc_preg (cfg);
          D.43295 = (int) D.43294;
          D.43288->dreg = D.43295;
          D.43288 = args[1];
          D.43296 = cache_ins->dreg;
          D.43288->sreg1 = D.43296;
          D.43288 = args[1];
          D.43288->data.op[0].const_val = 8;
          D.43288 = args[1];
          D.43288->type = 1;
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          if (D.43298 != 0B) goto <D.43299>; else goto <D.43300>;
          <D.43299>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43288 = args[1];
          D.43298->next = D.43288;
          D.43288 = args[1];
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43288->prev = D.43298;
          D.43297 = cfg->cbb;
          D.43288 = args[1];
          D.43297->last_ins = D.43288;
          goto <D.43301>;
          <D.43300>:
          D.43297 = cfg->cbb;
          D.43297 = cfg->cbb;
          D.43288 = args[1];
          D.43297->last_ins = D.43288;
          D.43298 = D.43297->last_ins;
          D.43297->code = D.43298;
          <D.43301>:
          args[2] = cache_ins;
          D.43302 = mono_emit_method_call (cfg, mono_isinst, &args, 0B);
          return D.43302;
        }
        <D.43285>:
        klass_inst = emit_get_rgctx_klass (cfg, context_used, klass, 1);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
  <D.43283>:
  D.43286 = cfg->mempool;
  is_null_bb = mono_mempool_alloc0 (D.43286, 296);
  D.43303 = cfg->num_bblocks;
  D.43304 = D.43303;
  D.43305 = D.43304 + 1;
  cfg->num_bblocks = D.43305;
  D.43306 = (int) D.43304;
  is_null_bb->block_num = D.43306;
  D.43286 = cfg->mempool;
  false_bb = mono_mempool_alloc0 (D.43286, 296);
  D.43303 = cfg->num_bblocks;
  D.43307 = D.43303;
  D.43308 = D.43307 + 1;
  cfg->num_bblocks = D.43308;
  D.43309 = (int) D.43307;
  false_bb->block_num = D.43309;
  D.43286 = cfg->mempool;
  end_bb = mono_mempool_alloc0 (D.43286, 296);
  D.43303 = cfg->num_bblocks;
  D.43310 = D.43303;
  D.43311 = D.43310 + 1;
  cfg->num_bblocks = D.43311;
  D.43312 = (int) D.43310;
  end_bb->block_num = D.43312;
  D.43286 = cfg->mempool;
  ins = mono_mempool_alloc (D.43286, 80);
  ins->data.op[1].const_val = 0;
  D.43313 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.43313;
  ins->prev = 0B;
  D.43314 = ins->prev;
  ins->next = D.43314;
  ins->opcode = 424;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.43315 = ins->sreg3;
  ins->sreg2 = D.43315;
  D.43316 = ins->sreg2;
  ins->sreg1 = D.43316;
  D.43293 = cfg->ip;
  ins->cil_code = D.43293;
  ins->dreg = res_reg;
  ins->sreg1 = obj_reg;
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  if (D.43298 != 0B) goto <D.43317>; else goto <D.43318>;
  <D.43317>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43298->next = ins;
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  ins->prev = D.43298;
  D.43297 = cfg->cbb;
  D.43297->last_ins = ins;
  goto <D.43319>;
  <D.43318>:
  D.43297 = cfg->cbb;
  D.43297 = cfg->cbb;
  D.43297->last_ins = ins;
  D.43298 = D.43297->last_ins;
  D.43297->code = D.43298;
  <D.43319>:
  ins->type = 6;
  ins->klass = klass;
  {
    struct MonoInst * inst;

    D.43286 = cfg->mempool;
    inst = mono_mempool_alloc (D.43286, 80);
    inst->data.op[1].const_val = 0;
    D.43320 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.43320;
    inst->prev = 0B;
    D.43321 = inst->prev;
    inst->next = D.43321;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.43322 = inst->sreg3;
    inst->sreg2 = D.43322;
    D.43323 = inst->sreg2;
    inst->sreg1 = D.43323;
    D.43293 = cfg->ip;
    inst->cil_code = D.43293;
    inst->dreg = -1;
    inst->sreg1 = obj_reg;
    inst->data.op[1].const_val = 0;
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    if (D.43298 != 0B) goto <D.43324>; else goto <D.43325>;
    <D.43324>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43298->next = inst;
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    inst->prev = D.43298;
    D.43297 = cfg->cbb;
    D.43297->last_ins = inst;
    goto <D.43326>;
    <D.43325>:
    D.43297 = cfg->cbb;
    D.43297 = cfg->cbb;
    D.43297->last_ins = inst;
    D.43298 = D.43297->last_ins;
    D.43297->code = D.43298;
    <D.43326>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.43286 = cfg->mempool;
    ins = mono_mempool_alloc (D.43286, 80);
    ins->data.op[1].const_val = 0;
    D.43327 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.43327;
    ins->prev = 0B;
    D.43328 = ins->prev;
    ins->next = D.43328;
    ins->opcode = 648;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.43329 = ins->sreg3;
    ins->sreg2 = D.43329;
    D.43330 = ins->sreg2;
    ins->sreg1 = D.43330;
    D.43293 = cfg->ip;
    ins->cil_code = D.43293;
    if (0 != 0) goto <D.43331>; else goto <D.43332>;
    <D.43331>:
    D.43286 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.43286, 296);
    D.43303 = cfg->num_bblocks;
    D.43333 = D.43303;
    D.43334 = D.43333 + 1;
    cfg->num_bblocks = D.43334;
    D.43335 = (int) D.43333;
    falsebb->block_num = D.43335;
    ins->data.op[0].target_block = is_null_bb;
    D.43297 = cfg->cbb;
    mono_link_bblock (cfg, D.43297, is_null_bb);
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    if (D.43298 != 0B) goto <D.43336>; else goto <D.43337>;
    <D.43336>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43298->next = ins;
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    ins->prev = D.43298;
    D.43297 = cfg->cbb;
    D.43297->last_ins = ins;
    goto <D.43338>;
    <D.43337>:
    D.43297 = cfg->cbb;
    D.43297 = cfg->cbb;
    D.43297->last_ins = ins;
    D.43298 = D.43297->last_ins;
    D.43297->code = D.43298;
    <D.43338>:
    D.43339 = falsebb->cil_code;
    if (D.43339 != 0B) goto <D.43340>; else goto <D.43341>;
    <D.43340>:
    D.43342 = cfg->cil_offset_to_bb;
    D.43339 = falsebb->cil_code;
    D.43343 = (long int) D.43339;
    D.43344 = cfg->cil_start;
    D.43345 = (long int) D.43344;
    D.43346 = D.43343 - D.43345;
    D.43347 = (long unsigned int) D.43346;
    D.43348 = D.43347 * 8;
    D.43349 = D.43342 + D.43348;
    *D.43349 = falsebb;
    <D.43341>:
    D.43350 = cfg->real_offset;
    falsebb->real_offset = D.43350;
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    if (D.43298 != 0B) goto <D.43354>; else goto <D.43351>;
    <D.43354>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43356 = D.43355 + 64985;
    if (D.43356 <= 9) goto <D.43352>; else goto <D.43357>;
    <D.43357>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43358 = D.43355 + 64878;
    if (D.43358 <= 9) goto <D.43352>; else goto <D.43359>;
    <D.43359>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43360 = D.43355 + 64888;
    if (D.43360 <= 9) goto <D.43352>; else goto <D.43351>;
    <D.43352>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43361 = D.43298->data.op[1].many_blocks;
    D.43362 = D.43361 + 8;
    D.43363 = *D.43362;
    if (D.43363 == 0B) goto <D.43364>; else goto <D.43351>;
    <D.43364>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43361 = D.43298->data.op[1].many_blocks;
    D.43362 = D.43361 + 8;
    *D.43362 = falsebb;
    D.43297 = cfg->cbb;
    mono_link_bblock (cfg, D.43297, falsebb);
    goto <D.43353>;
    <D.43351>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    if (D.43298 == 0B) goto <D.43365>; else goto <D.43367>;
    <D.43367>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    if (D.43355 != 442) goto <D.43368>; else goto <D.43366>;
    <D.43368>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    if (D.43355 != 759) goto <D.43369>; else goto <D.43366>;
    <D.43369>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43356 = D.43355 + 64985;
    if (D.43356 > 9) goto <D.43370>; else goto <D.43366>;
    <D.43370>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43358 = D.43355 + 64878;
    if (D.43358 > 9) goto <D.43371>; else goto <D.43366>;
    <D.43371>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43360 = D.43355 + 64888;
    if (D.43360 > 9) goto <D.43365>; else goto <D.43366>;
    <D.43365>:
    D.43297 = cfg->cbb;
    mono_link_bblock (cfg, D.43297, falsebb);
    <D.43366>:
    <D.43353>:
    D.43297 = cfg->cbb;
    D.43297->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.43372>;
    <D.43332>:
    D.43286 = cfg->mempool;
    D.43373 = mono_mempool_alloc (D.43286, 16);
    ins->data.op[1].many_blocks = D.43373;
    D.43374 = ins->data.op[1].many_blocks;
    *D.43374 = is_null_bb;
    D.43374 = ins->data.op[1].many_blocks;
    D.43375 = D.43374 + 8;
    *D.43375 = 0B;
    D.43297 = cfg->cbb;
    mono_link_bblock (cfg, D.43297, is_null_bb);
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    if (D.43298 != 0B) goto <D.43376>; else goto <D.43377>;
    <D.43376>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43298->next = ins;
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    ins->prev = D.43298;
    D.43297 = cfg->cbb;
    D.43297->last_ins = ins;
    goto <D.43378>;
    <D.43377>:
    D.43297 = cfg->cbb;
    D.43297 = cfg->cbb;
    D.43297->last_ins = ins;
    D.43298 = D.43297->last_ins;
    D.43297->code = D.43298;
    <D.43378>:
    D.43379 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.43380 = D.43379 & 268435456;
    if (D.43380 == 0) goto <D.43381>; else goto <D.43382>;
    <D.43381>:
    D.43286 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.43286, 296);
    D.43303 = cfg->num_bblocks;
    D.43383 = D.43303;
    D.43384 = D.43383 + 1;
    cfg->num_bblocks = D.43384;
    D.43385 = (int) D.43383;
    falsebb->block_num = D.43385;
    D.43374 = ins->data.op[1].many_blocks;
    D.43375 = D.43374 + 8;
    *D.43375 = falsebb;
    D.43297 = cfg->cbb;
    mono_link_bblock (cfg, D.43297, falsebb);
    D.43339 = falsebb->cil_code;
    if (D.43339 != 0B) goto <D.43386>; else goto <D.43387>;
    <D.43386>:
    D.43342 = cfg->cil_offset_to_bb;
    D.43339 = falsebb->cil_code;
    D.43343 = (long int) D.43339;
    D.43344 = cfg->cil_start;
    D.43345 = (long int) D.43344;
    D.43346 = D.43343 - D.43345;
    D.43347 = (long unsigned int) D.43346;
    D.43348 = D.43347 * 8;
    D.43349 = D.43342 + D.43348;
    *D.43349 = falsebb;
    <D.43387>:
    D.43350 = cfg->real_offset;
    falsebb->real_offset = D.43350;
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    if (D.43298 != 0B) goto <D.43391>; else goto <D.43388>;
    <D.43391>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43356 = D.43355 + 64985;
    if (D.43356 <= 9) goto <D.43389>; else goto <D.43392>;
    <D.43392>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43358 = D.43355 + 64878;
    if (D.43358 <= 9) goto <D.43389>; else goto <D.43393>;
    <D.43393>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43360 = D.43355 + 64888;
    if (D.43360 <= 9) goto <D.43389>; else goto <D.43388>;
    <D.43389>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43361 = D.43298->data.op[1].many_blocks;
    D.43362 = D.43361 + 8;
    D.43363 = *D.43362;
    if (D.43363 == 0B) goto <D.43394>; else goto <D.43388>;
    <D.43394>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43361 = D.43298->data.op[1].many_blocks;
    D.43362 = D.43361 + 8;
    *D.43362 = falsebb;
    D.43297 = cfg->cbb;
    mono_link_bblock (cfg, D.43297, falsebb);
    goto <D.43390>;
    <D.43388>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    if (D.43298 == 0B) goto <D.43395>; else goto <D.43397>;
    <D.43397>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    if (D.43355 != 442) goto <D.43398>; else goto <D.43396>;
    <D.43398>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    if (D.43355 != 759) goto <D.43399>; else goto <D.43396>;
    <D.43399>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43356 = D.43355 + 64985;
    if (D.43356 > 9) goto <D.43400>; else goto <D.43396>;
    <D.43400>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43358 = D.43355 + 64878;
    if (D.43358 > 9) goto <D.43401>; else goto <D.43396>;
    <D.43401>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43360 = D.43355 + 64888;
    if (D.43360 > 9) goto <D.43395>; else goto <D.43396>;
    <D.43395>:
    D.43297 = cfg->cbb;
    mono_link_bblock (cfg, D.43297, falsebb);
    <D.43396>:
    <D.43390>:
    D.43297 = cfg->cbb;
    D.43297->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.43402>;
    <D.43382>:
    D.43297 = cfg->cbb;
    D.43297->extended = 1;
    <D.43402>:
    <D.43372>:
  }
  {
    struct MonoInst * inst;

    D.43286 = cfg->mempool;
    inst = mono_mempool_alloc (D.43286, 80);
    inst->data.op[1].const_val = 0;
    D.43403 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.43403;
    inst->prev = 0B;
    D.43404 = inst->prev;
    inst->next = D.43404;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.43405 = inst->sreg3;
    inst->sreg2 = D.43405;
    D.43406 = inst->sreg2;
    inst->sreg1 = D.43406;
    D.43293 = cfg->ip;
    inst->cil_code = D.43293;
    inst->dreg = vtable_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 0;
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    if (D.43298 != 0B) goto <D.43407>; else goto <D.43408>;
    <D.43407>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43298->next = inst;
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    inst->prev = D.43298;
    D.43297 = cfg->cbb;
    D.43297->last_ins = inst;
    goto <D.43409>;
    <D.43408>:
    D.43297 = cfg->cbb;
    D.43297 = cfg->cbb;
    D.43297->last_ins = inst;
    D.43298 = D.43297->last_ins;
    D.43297->code = D.43298;
    <D.43409>:
  }
  D.43410 = klass->flags;
  D.43411 = D.43410 & 32;
  if (D.43411 != 0) goto <D.43412>; else goto <D.43413>;
  <D.43412>:
  D.43414 = context_used != 0;
  D.43415 = (long int) D.43414;
  D.43416 = __builtin_expect (D.43415, 0);
  if (D.43416 != 0) goto <D.43417>; else goto <D.43418>;
  <D.43417>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4086, "!context_used");
  <D.43418>:
  mini_emit_iface_cast (cfg, vtable_reg, klass, false_bb, is_null_bb);
  goto <D.43419>;
  <D.43413>:
  {
    int klass_reg;

    D.43420 = alloc_preg (cfg);
    klass_reg = (int) D.43420;
    D.43421 = klass->rank;
    if (D.43421 != 0) goto <D.43422>; else goto <D.43423>;
    <D.43422>:
    {
      int rank_reg;
      int eclass_reg;

      D.43424 = alloc_preg (cfg);
      rank_reg = (int) D.43424;
      D.43425 = alloc_preg (cfg);
      eclass_reg = (int) D.43425;
      D.43414 = context_used != 0;
      D.43415 = (long int) D.43414;
      D.43416 = __builtin_expect (D.43415, 0);
      if (D.43416 != 0) goto <D.43426>; else goto <D.43427>;
      <D.43426>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4096, "!context_used");
      <D.43427>:
      {
        struct MonoInst * inst;

        D.43286 = cfg->mempool;
        inst = mono_mempool_alloc (D.43286, 80);
        inst->data.op[1].const_val = 0;
        D.43428 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.43428;
        inst->prev = 0B;
        D.43429 = inst->prev;
        inst->next = D.43429;
        inst->opcode = 390;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.43430 = inst->sreg3;
        inst->sreg2 = D.43430;
        D.43431 = inst->sreg2;
        inst->sreg1 = D.43431;
        D.43293 = cfg->ip;
        inst->cil_code = D.43293;
        inst->dreg = rank_reg;
        inst->sreg1 = vtable_reg;
        inst->data.op[0].const_val = 42;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 != 0B) goto <D.43432>; else goto <D.43433>;
        <D.43432>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43298->next = inst;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        inst->prev = D.43298;
        D.43297 = cfg->cbb;
        D.43297->last_ins = inst;
        goto <D.43434>;
        <D.43433>:
        D.43297 = cfg->cbb;
        D.43297 = cfg->cbb;
        D.43297->last_ins = inst;
        D.43298 = D.43297->last_ins;
        D.43297->code = D.43298;
        <D.43434>:
      }
      {
        struct MonoInst * inst;

        D.43286 = cfg->mempool;
        inst = mono_mempool_alloc (D.43286, 80);
        inst->data.op[1].const_val = 0;
        D.43435 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.43435;
        inst->prev = 0B;
        D.43436 = inst->prev;
        inst->next = D.43436;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.43437 = inst->sreg3;
        inst->sreg2 = D.43437;
        D.43438 = inst->sreg2;
        inst->sreg1 = D.43438;
        D.43293 = cfg->ip;
        inst->cil_code = D.43293;
        inst->dreg = -1;
        inst->sreg1 = rank_reg;
        D.43421 = klass->rank;
        D.43439 = (long int) D.43421;
        inst->data.op[1].const_val = D.43439;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 != 0B) goto <D.43440>; else goto <D.43441>;
        <D.43440>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43298->next = inst;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        inst->prev = D.43298;
        D.43297 = cfg->cbb;
        D.43297->last_ins = inst;
        goto <D.43442>;
        <D.43441>:
        D.43297 = cfg->cbb;
        D.43297 = cfg->cbb;
        D.43297->last_ins = inst;
        D.43298 = D.43297->last_ins;
        D.43297->code = D.43298;
        <D.43442>:
      }
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.43286 = cfg->mempool;
        ins = mono_mempool_alloc (D.43286, 80);
        ins->data.op[1].const_val = 0;
        D.43443 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.43443;
        ins->prev = 0B;
        D.43444 = ins->prev;
        ins->next = D.43444;
        ins->opcode = 556;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.43445 = ins->sreg3;
        ins->sreg2 = D.43445;
        D.43446 = ins->sreg2;
        ins->sreg1 = D.43446;
        D.43293 = cfg->ip;
        ins->cil_code = D.43293;
        if (0 != 0) goto <D.43447>; else goto <D.43448>;
        <D.43447>:
        D.43286 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.43286, 296);
        D.43303 = cfg->num_bblocks;
        D.43449 = D.43303;
        D.43450 = D.43449 + 1;
        cfg->num_bblocks = D.43450;
        D.43451 = (int) D.43449;
        falsebb->block_num = D.43451;
        ins->data.op[0].target_block = false_bb;
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, false_bb);
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 != 0B) goto <D.43452>; else goto <D.43453>;
        <D.43452>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43298->next = ins;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        ins->prev = D.43298;
        D.43297 = cfg->cbb;
        D.43297->last_ins = ins;
        goto <D.43454>;
        <D.43453>:
        D.43297 = cfg->cbb;
        D.43297 = cfg->cbb;
        D.43297->last_ins = ins;
        D.43298 = D.43297->last_ins;
        D.43297->code = D.43298;
        <D.43454>:
        D.43455 = falsebb->cil_code;
        if (D.43455 != 0B) goto <D.43456>; else goto <D.43457>;
        <D.43456>:
        D.43342 = cfg->cil_offset_to_bb;
        D.43455 = falsebb->cil_code;
        D.43458 = (long int) D.43455;
        D.43344 = cfg->cil_start;
        D.43345 = (long int) D.43344;
        D.43459 = D.43458 - D.43345;
        D.43460 = (long unsigned int) D.43459;
        D.43461 = D.43460 * 8;
        D.43462 = D.43342 + D.43461;
        *D.43462 = falsebb;
        <D.43457>:
        D.43350 = cfg->real_offset;
        falsebb->real_offset = D.43350;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 != 0B) goto <D.43466>; else goto <D.43463>;
        <D.43466>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43356 = D.43355 + 64985;
        if (D.43356 <= 9) goto <D.43464>; else goto <D.43467>;
        <D.43467>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43358 = D.43355 + 64878;
        if (D.43358 <= 9) goto <D.43464>; else goto <D.43468>;
        <D.43468>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43360 = D.43355 + 64888;
        if (D.43360 <= 9) goto <D.43464>; else goto <D.43463>;
        <D.43464>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43361 = D.43298->data.op[1].many_blocks;
        D.43362 = D.43361 + 8;
        D.43363 = *D.43362;
        if (D.43363 == 0B) goto <D.43469>; else goto <D.43463>;
        <D.43469>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43361 = D.43298->data.op[1].many_blocks;
        D.43362 = D.43361 + 8;
        *D.43362 = falsebb;
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, falsebb);
        goto <D.43465>;
        <D.43463>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 == 0B) goto <D.43470>; else goto <D.43472>;
        <D.43472>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        if (D.43355 != 442) goto <D.43473>; else goto <D.43471>;
        <D.43473>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        if (D.43355 != 759) goto <D.43474>; else goto <D.43471>;
        <D.43474>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43356 = D.43355 + 64985;
        if (D.43356 > 9) goto <D.43475>; else goto <D.43471>;
        <D.43475>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43358 = D.43355 + 64878;
        if (D.43358 > 9) goto <D.43476>; else goto <D.43471>;
        <D.43476>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43360 = D.43355 + 64888;
        if (D.43360 > 9) goto <D.43470>; else goto <D.43471>;
        <D.43470>:
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, falsebb);
        <D.43471>:
        <D.43465>:
        D.43297 = cfg->cbb;
        D.43297->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.43477>;
        <D.43448>:
        D.43286 = cfg->mempool;
        D.43478 = mono_mempool_alloc (D.43286, 16);
        ins->data.op[1].many_blocks = D.43478;
        D.43479 = ins->data.op[1].many_blocks;
        *D.43479 = false_bb;
        D.43479 = ins->data.op[1].many_blocks;
        D.43480 = D.43479 + 8;
        *D.43480 = 0B;
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, false_bb);
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 != 0B) goto <D.43481>; else goto <D.43482>;
        <D.43481>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43298->next = ins;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        ins->prev = D.43298;
        D.43297 = cfg->cbb;
        D.43297->last_ins = ins;
        goto <D.43483>;
        <D.43482>:
        D.43297 = cfg->cbb;
        D.43297 = cfg->cbb;
        D.43297->last_ins = ins;
        D.43298 = D.43297->last_ins;
        D.43297->code = D.43298;
        <D.43483>:
        D.43379 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.43380 = D.43379 & 268435456;
        if (D.43380 == 0) goto <D.43484>; else goto <D.43485>;
        <D.43484>:
        D.43286 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.43286, 296);
        D.43303 = cfg->num_bblocks;
        D.43486 = D.43303;
        D.43487 = D.43486 + 1;
        cfg->num_bblocks = D.43487;
        D.43488 = (int) D.43486;
        falsebb->block_num = D.43488;
        D.43479 = ins->data.op[1].many_blocks;
        D.43480 = D.43479 + 8;
        *D.43480 = falsebb;
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, falsebb);
        D.43455 = falsebb->cil_code;
        if (D.43455 != 0B) goto <D.43489>; else goto <D.43490>;
        <D.43489>:
        D.43342 = cfg->cil_offset_to_bb;
        D.43455 = falsebb->cil_code;
        D.43458 = (long int) D.43455;
        D.43344 = cfg->cil_start;
        D.43345 = (long int) D.43344;
        D.43459 = D.43458 - D.43345;
        D.43460 = (long unsigned int) D.43459;
        D.43461 = D.43460 * 8;
        D.43462 = D.43342 + D.43461;
        *D.43462 = falsebb;
        <D.43490>:
        D.43350 = cfg->real_offset;
        falsebb->real_offset = D.43350;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 != 0B) goto <D.43494>; else goto <D.43491>;
        <D.43494>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43356 = D.43355 + 64985;
        if (D.43356 <= 9) goto <D.43492>; else goto <D.43495>;
        <D.43495>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43358 = D.43355 + 64878;
        if (D.43358 <= 9) goto <D.43492>; else goto <D.43496>;
        <D.43496>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43360 = D.43355 + 64888;
        if (D.43360 <= 9) goto <D.43492>; else goto <D.43491>;
        <D.43492>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43361 = D.43298->data.op[1].many_blocks;
        D.43362 = D.43361 + 8;
        D.43363 = *D.43362;
        if (D.43363 == 0B) goto <D.43497>; else goto <D.43491>;
        <D.43497>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43361 = D.43298->data.op[1].many_blocks;
        D.43362 = D.43361 + 8;
        *D.43362 = falsebb;
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, falsebb);
        goto <D.43493>;
        <D.43491>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 == 0B) goto <D.43498>; else goto <D.43500>;
        <D.43500>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        if (D.43355 != 442) goto <D.43501>; else goto <D.43499>;
        <D.43501>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        if (D.43355 != 759) goto <D.43502>; else goto <D.43499>;
        <D.43502>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43356 = D.43355 + 64985;
        if (D.43356 > 9) goto <D.43503>; else goto <D.43499>;
        <D.43503>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43358 = D.43355 + 64878;
        if (D.43358 > 9) goto <D.43504>; else goto <D.43499>;
        <D.43504>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43360 = D.43355 + 64888;
        if (D.43360 > 9) goto <D.43498>; else goto <D.43499>;
        <D.43498>:
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, falsebb);
        <D.43499>:
        <D.43493>:
        D.43297 = cfg->cbb;
        D.43297->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.43505>;
        <D.43485>:
        D.43297 = cfg->cbb;
        D.43297->extended = 1;
        <D.43505>:
        <D.43477>:
      }
      {
        struct MonoInst * inst;

        D.43286 = cfg->mempool;
        inst = mono_mempool_alloc (D.43286, 80);
        inst->data.op[1].const_val = 0;
        D.43506 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.43506;
        inst->prev = 0B;
        D.43507 = inst->prev;
        inst->next = D.43507;
        inst->opcode = 388;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.43508 = inst->sreg3;
        inst->sreg2 = D.43508;
        D.43509 = inst->sreg2;
        inst->sreg1 = D.43509;
        D.43293 = cfg->ip;
        inst->cil_code = D.43293;
        inst->dreg = klass_reg;
        inst->sreg1 = vtable_reg;
        inst->data.op[0].const_val = 0;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 != 0B) goto <D.43510>; else goto <D.43511>;
        <D.43510>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43298->next = inst;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        inst->prev = D.43298;
        D.43297 = cfg->cbb;
        D.43297->last_ins = inst;
        goto <D.43512>;
        <D.43511>:
        D.43297 = cfg->cbb;
        D.43297 = cfg->cbb;
        D.43297->last_ins = inst;
        D.43298 = D.43297->last_ins;
        D.43297->code = D.43298;
        <D.43512>:
      }
      {
        struct MonoInst * inst;

        D.43286 = cfg->mempool;
        inst = mono_mempool_alloc (D.43286, 80);
        inst->data.op[1].const_val = 0;
        D.43513 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.43513;
        inst->prev = 0B;
        D.43514 = inst->prev;
        inst->next = D.43514;
        inst->opcode = 388;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.43515 = inst->sreg3;
        inst->sreg2 = D.43515;
        D.43516 = inst->sreg2;
        inst->sreg1 = D.43516;
        D.43293 = cfg->ip;
        inst->cil_code = D.43293;
        inst->dreg = eclass_reg;
        inst->sreg1 = klass_reg;
        inst->data.op[0].const_val = 8;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 != 0B) goto <D.43517>; else goto <D.43518>;
        <D.43517>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43298->next = inst;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        inst->prev = D.43298;
        D.43297 = cfg->cbb;
        D.43297->last_ins = inst;
        goto <D.43519>;
        <D.43518>:
        D.43297 = cfg->cbb;
        D.43297 = cfg->cbb;
        D.43297->last_ins = inst;
        D.43298 = D.43297->last_ins;
        D.43297->code = D.43298;
        <D.43519>:
      }
      D.43520 = klass->cast_class;
      D.43521 = mono_defaults.object_class;
      if (D.43520 == D.43521) goto <D.43522>; else goto <D.43523>;
      <D.43522>:
      {
        int parent_reg;

        D.43524 = alloc_preg (cfg);
        parent_reg = (int) D.43524;
        {
          struct MonoInst * inst;

          D.43286 = cfg->mempool;
          inst = mono_mempool_alloc (D.43286, 80);
          inst->data.op[1].const_val = 0;
          D.43525 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.43525;
          inst->prev = 0B;
          D.43526 = inst->prev;
          inst->next = D.43526;
          inst->opcode = 388;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.43527 = inst->sreg3;
          inst->sreg2 = D.43527;
          D.43528 = inst->sreg2;
          inst->sreg1 = D.43528;
          D.43293 = cfg->ip;
          inst->cil_code = D.43293;
          inst->dreg = parent_reg;
          inst->sreg1 = eclass_reg;
          inst->data.op[0].const_val = 40;
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          if (D.43298 != 0B) goto <D.43529>; else goto <D.43530>;
          <D.43529>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43298->next = inst;
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          inst->prev = D.43298;
          D.43297 = cfg->cbb;
          D.43297->last_ins = inst;
          goto <D.43531>;
          <D.43530>:
          D.43297 = cfg->cbb;
          D.43297 = cfg->cbb;
          D.43297->last_ins = inst;
          D.43298 = D.43297->last_ins;
          D.43297->code = D.43298;
          <D.43531>:
        }
        D.43532 = mono_defaults.enum_class;
        D.43533 = D.43532->parent;
        mini_emit_class_check_branch (cfg, parent_reg, D.43533, 556, is_null_bb);
        D.43532 = mono_defaults.enum_class;
        mini_emit_class_check_branch (cfg, eclass_reg, D.43532, 551, is_null_bb);
        {
          struct MonoInst * ins;
          struct MonoBasicBlock * falsebb;

          D.43286 = cfg->mempool;
          ins = mono_mempool_alloc (D.43286, 80);
          ins->data.op[1].const_val = 0;
          D.43534 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.43534;
          ins->prev = 0B;
          D.43535 = ins->prev;
          ins->next = D.43535;
          ins->opcode = 442;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.43536 = ins->sreg3;
          ins->sreg2 = D.43536;
          D.43537 = ins->sreg2;
          ins->sreg1 = D.43537;
          D.43293 = cfg->ip;
          ins->cil_code = D.43293;
          if (1 != 0) goto <D.43538>; else goto <D.43539>;
          <D.43538>:
          D.43286 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.43286, 296);
          D.43303 = cfg->num_bblocks;
          D.43540 = D.43303;
          D.43541 = D.43540 + 1;
          cfg->num_bblocks = D.43541;
          D.43542 = (int) D.43540;
          falsebb->block_num = D.43542;
          ins->data.op[0].target_block = false_bb;
          D.43297 = cfg->cbb;
          mono_link_bblock (cfg, D.43297, false_bb);
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          if (D.43298 != 0B) goto <D.43543>; else goto <D.43544>;
          <D.43543>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43298->next = ins;
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          ins->prev = D.43298;
          D.43297 = cfg->cbb;
          D.43297->last_ins = ins;
          goto <D.43545>;
          <D.43544>:
          D.43297 = cfg->cbb;
          D.43297 = cfg->cbb;
          D.43297->last_ins = ins;
          D.43298 = D.43297->last_ins;
          D.43297->code = D.43298;
          <D.43545>:
          D.43546 = falsebb->cil_code;
          if (D.43546 != 0B) goto <D.43547>; else goto <D.43548>;
          <D.43547>:
          D.43342 = cfg->cil_offset_to_bb;
          D.43546 = falsebb->cil_code;
          D.43549 = (long int) D.43546;
          D.43344 = cfg->cil_start;
          D.43345 = (long int) D.43344;
          D.43550 = D.43549 - D.43345;
          D.43551 = (long unsigned int) D.43550;
          D.43552 = D.43551 * 8;
          D.43553 = D.43342 + D.43552;
          *D.43553 = falsebb;
          <D.43548>:
          D.43350 = cfg->real_offset;
          falsebb->real_offset = D.43350;
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          if (D.43298 != 0B) goto <D.43557>; else goto <D.43554>;
          <D.43557>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43356 = D.43355 + 64985;
          if (D.43356 <= 9) goto <D.43555>; else goto <D.43558>;
          <D.43558>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43358 = D.43355 + 64878;
          if (D.43358 <= 9) goto <D.43555>; else goto <D.43559>;
          <D.43559>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43360 = D.43355 + 64888;
          if (D.43360 <= 9) goto <D.43555>; else goto <D.43554>;
          <D.43555>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43361 = D.43298->data.op[1].many_blocks;
          D.43362 = D.43361 + 8;
          D.43363 = *D.43362;
          if (D.43363 == 0B) goto <D.43560>; else goto <D.43554>;
          <D.43560>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43361 = D.43298->data.op[1].many_blocks;
          D.43362 = D.43361 + 8;
          *D.43362 = falsebb;
          D.43297 = cfg->cbb;
          mono_link_bblock (cfg, D.43297, falsebb);
          goto <D.43556>;
          <D.43554>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          if (D.43298 == 0B) goto <D.43561>; else goto <D.43563>;
          <D.43563>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          if (D.43355 != 442) goto <D.43564>; else goto <D.43562>;
          <D.43564>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          if (D.43355 != 759) goto <D.43565>; else goto <D.43562>;
          <D.43565>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43356 = D.43355 + 64985;
          if (D.43356 > 9) goto <D.43566>; else goto <D.43562>;
          <D.43566>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43358 = D.43355 + 64878;
          if (D.43358 > 9) goto <D.43567>; else goto <D.43562>;
          <D.43567>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43360 = D.43355 + 64888;
          if (D.43360 > 9) goto <D.43561>; else goto <D.43562>;
          <D.43561>:
          D.43297 = cfg->cbb;
          mono_link_bblock (cfg, D.43297, falsebb);
          <D.43562>:
          <D.43556>:
          D.43297 = cfg->cbb;
          D.43297->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.43568>;
          <D.43539>:
          D.43286 = cfg->mempool;
          D.43569 = mono_mempool_alloc (D.43286, 16);
          ins->data.op[1].many_blocks = D.43569;
          D.43570 = ins->data.op[1].many_blocks;
          *D.43570 = false_bb;
          D.43570 = ins->data.op[1].many_blocks;
          D.43571 = D.43570 + 8;
          *D.43571 = 0B;
          D.43297 = cfg->cbb;
          mono_link_bblock (cfg, D.43297, false_bb);
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          if (D.43298 != 0B) goto <D.43572>; else goto <D.43573>;
          <D.43572>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43298->next = ins;
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          ins->prev = D.43298;
          D.43297 = cfg->cbb;
          D.43297->last_ins = ins;
          goto <D.43574>;
          <D.43573>:
          D.43297 = cfg->cbb;
          D.43297 = cfg->cbb;
          D.43297->last_ins = ins;
          D.43298 = D.43297->last_ins;
          D.43297->code = D.43298;
          <D.43574>:
          D.43379 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.43380 = D.43379 & 268435456;
          if (D.43380 == 0) goto <D.43575>; else goto <D.43576>;
          <D.43575>:
          D.43286 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.43286, 296);
          D.43303 = cfg->num_bblocks;
          D.43577 = D.43303;
          D.43578 = D.43577 + 1;
          cfg->num_bblocks = D.43578;
          D.43579 = (int) D.43577;
          falsebb->block_num = D.43579;
          D.43570 = ins->data.op[1].many_blocks;
          D.43571 = D.43570 + 8;
          *D.43571 = falsebb;
          D.43297 = cfg->cbb;
          mono_link_bblock (cfg, D.43297, falsebb);
          D.43546 = falsebb->cil_code;
          if (D.43546 != 0B) goto <D.43580>; else goto <D.43581>;
          <D.43580>:
          D.43342 = cfg->cil_offset_to_bb;
          D.43546 = falsebb->cil_code;
          D.43549 = (long int) D.43546;
          D.43344 = cfg->cil_start;
          D.43345 = (long int) D.43344;
          D.43550 = D.43549 - D.43345;
          D.43551 = (long unsigned int) D.43550;
          D.43552 = D.43551 * 8;
          D.43553 = D.43342 + D.43552;
          *D.43553 = falsebb;
          <D.43581>:
          D.43350 = cfg->real_offset;
          falsebb->real_offset = D.43350;
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          if (D.43298 != 0B) goto <D.43585>; else goto <D.43582>;
          <D.43585>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43356 = D.43355 + 64985;
          if (D.43356 <= 9) goto <D.43583>; else goto <D.43586>;
          <D.43586>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43358 = D.43355 + 64878;
          if (D.43358 <= 9) goto <D.43583>; else goto <D.43587>;
          <D.43587>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43360 = D.43355 + 64888;
          if (D.43360 <= 9) goto <D.43583>; else goto <D.43582>;
          <D.43583>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43361 = D.43298->data.op[1].many_blocks;
          D.43362 = D.43361 + 8;
          D.43363 = *D.43362;
          if (D.43363 == 0B) goto <D.43588>; else goto <D.43582>;
          <D.43588>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43361 = D.43298->data.op[1].many_blocks;
          D.43362 = D.43361 + 8;
          *D.43362 = falsebb;
          D.43297 = cfg->cbb;
          mono_link_bblock (cfg, D.43297, falsebb);
          goto <D.43584>;
          <D.43582>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          if (D.43298 == 0B) goto <D.43589>; else goto <D.43591>;
          <D.43591>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          if (D.43355 != 442) goto <D.43592>; else goto <D.43590>;
          <D.43592>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          if (D.43355 != 759) goto <D.43593>; else goto <D.43590>;
          <D.43593>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43356 = D.43355 + 64985;
          if (D.43356 > 9) goto <D.43594>; else goto <D.43590>;
          <D.43594>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43358 = D.43355 + 64878;
          if (D.43358 > 9) goto <D.43595>; else goto <D.43590>;
          <D.43595>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43360 = D.43355 + 64888;
          if (D.43360 > 9) goto <D.43589>; else goto <D.43590>;
          <D.43589>:
          D.43297 = cfg->cbb;
          mono_link_bblock (cfg, D.43297, falsebb);
          <D.43590>:
          <D.43584>:
          D.43297 = cfg->cbb;
          D.43297->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.43596>;
          <D.43576>:
          D.43297 = cfg->cbb;
          D.43297->extended = 1;
          <D.43596>:
          <D.43568>:
        }
      }
      goto <D.43597>;
      <D.43523>:
      D.43520 = klass->cast_class;
      D.43532 = mono_defaults.enum_class;
      D.43533 = D.43532->parent;
      if (D.43520 == D.43533) goto <D.43598>; else goto <D.43599>;
      <D.43598>:
      D.43532 = mono_defaults.enum_class;
      D.43533 = D.43532->parent;
      mini_emit_class_check_branch (cfg, eclass_reg, D.43533, 551, is_null_bb);
      D.43532 = mono_defaults.enum_class;
      mini_emit_class_check_branch (cfg, eclass_reg, D.43532, 551, is_null_bb);
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.43286 = cfg->mempool;
        ins = mono_mempool_alloc (D.43286, 80);
        ins->data.op[1].const_val = 0;
        D.43600 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.43600;
        ins->prev = 0B;
        D.43601 = ins->prev;
        ins->next = D.43601;
        ins->opcode = 442;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.43602 = ins->sreg3;
        ins->sreg2 = D.43602;
        D.43603 = ins->sreg2;
        ins->sreg1 = D.43603;
        D.43293 = cfg->ip;
        ins->cil_code = D.43293;
        if (1 != 0) goto <D.43604>; else goto <D.43605>;
        <D.43604>:
        D.43286 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.43286, 296);
        D.43303 = cfg->num_bblocks;
        D.43606 = D.43303;
        D.43607 = D.43606 + 1;
        cfg->num_bblocks = D.43607;
        D.43608 = (int) D.43606;
        falsebb->block_num = D.43608;
        ins->data.op[0].target_block = false_bb;
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, false_bb);
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 != 0B) goto <D.43609>; else goto <D.43610>;
        <D.43609>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43298->next = ins;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        ins->prev = D.43298;
        D.43297 = cfg->cbb;
        D.43297->last_ins = ins;
        goto <D.43611>;
        <D.43610>:
        D.43297 = cfg->cbb;
        D.43297 = cfg->cbb;
        D.43297->last_ins = ins;
        D.43298 = D.43297->last_ins;
        D.43297->code = D.43298;
        <D.43611>:
        D.43612 = falsebb->cil_code;
        if (D.43612 != 0B) goto <D.43613>; else goto <D.43614>;
        <D.43613>:
        D.43342 = cfg->cil_offset_to_bb;
        D.43612 = falsebb->cil_code;
        D.43615 = (long int) D.43612;
        D.43344 = cfg->cil_start;
        D.43345 = (long int) D.43344;
        D.43616 = D.43615 - D.43345;
        D.43617 = (long unsigned int) D.43616;
        D.43618 = D.43617 * 8;
        D.43619 = D.43342 + D.43618;
        *D.43619 = falsebb;
        <D.43614>:
        D.43350 = cfg->real_offset;
        falsebb->real_offset = D.43350;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 != 0B) goto <D.43623>; else goto <D.43620>;
        <D.43623>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43356 = D.43355 + 64985;
        if (D.43356 <= 9) goto <D.43621>; else goto <D.43624>;
        <D.43624>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43358 = D.43355 + 64878;
        if (D.43358 <= 9) goto <D.43621>; else goto <D.43625>;
        <D.43625>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43360 = D.43355 + 64888;
        if (D.43360 <= 9) goto <D.43621>; else goto <D.43620>;
        <D.43621>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43361 = D.43298->data.op[1].many_blocks;
        D.43362 = D.43361 + 8;
        D.43363 = *D.43362;
        if (D.43363 == 0B) goto <D.43626>; else goto <D.43620>;
        <D.43626>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43361 = D.43298->data.op[1].many_blocks;
        D.43362 = D.43361 + 8;
        *D.43362 = falsebb;
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, falsebb);
        goto <D.43622>;
        <D.43620>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 == 0B) goto <D.43627>; else goto <D.43629>;
        <D.43629>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        if (D.43355 != 442) goto <D.43630>; else goto <D.43628>;
        <D.43630>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        if (D.43355 != 759) goto <D.43631>; else goto <D.43628>;
        <D.43631>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43356 = D.43355 + 64985;
        if (D.43356 > 9) goto <D.43632>; else goto <D.43628>;
        <D.43632>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43358 = D.43355 + 64878;
        if (D.43358 > 9) goto <D.43633>; else goto <D.43628>;
        <D.43633>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43360 = D.43355 + 64888;
        if (D.43360 > 9) goto <D.43627>; else goto <D.43628>;
        <D.43627>:
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, falsebb);
        <D.43628>:
        <D.43622>:
        D.43297 = cfg->cbb;
        D.43297->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.43634>;
        <D.43605>:
        D.43286 = cfg->mempool;
        D.43635 = mono_mempool_alloc (D.43286, 16);
        ins->data.op[1].many_blocks = D.43635;
        D.43636 = ins->data.op[1].many_blocks;
        *D.43636 = false_bb;
        D.43636 = ins->data.op[1].many_blocks;
        D.43637 = D.43636 + 8;
        *D.43637 = 0B;
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, false_bb);
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 != 0B) goto <D.43638>; else goto <D.43639>;
        <D.43638>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43298->next = ins;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        ins->prev = D.43298;
        D.43297 = cfg->cbb;
        D.43297->last_ins = ins;
        goto <D.43640>;
        <D.43639>:
        D.43297 = cfg->cbb;
        D.43297 = cfg->cbb;
        D.43297->last_ins = ins;
        D.43298 = D.43297->last_ins;
        D.43297->code = D.43298;
        <D.43640>:
        D.43379 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.43380 = D.43379 & 268435456;
        if (D.43380 == 0) goto <D.43641>; else goto <D.43642>;
        <D.43641>:
        D.43286 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.43286, 296);
        D.43303 = cfg->num_bblocks;
        D.43643 = D.43303;
        D.43644 = D.43643 + 1;
        cfg->num_bblocks = D.43644;
        D.43645 = (int) D.43643;
        falsebb->block_num = D.43645;
        D.43636 = ins->data.op[1].many_blocks;
        D.43637 = D.43636 + 8;
        *D.43637 = falsebb;
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, falsebb);
        D.43612 = falsebb->cil_code;
        if (D.43612 != 0B) goto <D.43646>; else goto <D.43647>;
        <D.43646>:
        D.43342 = cfg->cil_offset_to_bb;
        D.43612 = falsebb->cil_code;
        D.43615 = (long int) D.43612;
        D.43344 = cfg->cil_start;
        D.43345 = (long int) D.43344;
        D.43616 = D.43615 - D.43345;
        D.43617 = (long unsigned int) D.43616;
        D.43618 = D.43617 * 8;
        D.43619 = D.43342 + D.43618;
        *D.43619 = falsebb;
        <D.43647>:
        D.43350 = cfg->real_offset;
        falsebb->real_offset = D.43350;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 != 0B) goto <D.43651>; else goto <D.43648>;
        <D.43651>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43356 = D.43355 + 64985;
        if (D.43356 <= 9) goto <D.43649>; else goto <D.43652>;
        <D.43652>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43358 = D.43355 + 64878;
        if (D.43358 <= 9) goto <D.43649>; else goto <D.43653>;
        <D.43653>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43360 = D.43355 + 64888;
        if (D.43360 <= 9) goto <D.43649>; else goto <D.43648>;
        <D.43649>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43361 = D.43298->data.op[1].many_blocks;
        D.43362 = D.43361 + 8;
        D.43363 = *D.43362;
        if (D.43363 == 0B) goto <D.43654>; else goto <D.43648>;
        <D.43654>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43361 = D.43298->data.op[1].many_blocks;
        D.43362 = D.43361 + 8;
        *D.43362 = falsebb;
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, falsebb);
        goto <D.43650>;
        <D.43648>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 == 0B) goto <D.43655>; else goto <D.43657>;
        <D.43657>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        if (D.43355 != 442) goto <D.43658>; else goto <D.43656>;
        <D.43658>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        if (D.43355 != 759) goto <D.43659>; else goto <D.43656>;
        <D.43659>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43356 = D.43355 + 64985;
        if (D.43356 > 9) goto <D.43660>; else goto <D.43656>;
        <D.43660>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43358 = D.43355 + 64878;
        if (D.43358 > 9) goto <D.43661>; else goto <D.43656>;
        <D.43661>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43360 = D.43355 + 64888;
        if (D.43360 > 9) goto <D.43655>; else goto <D.43656>;
        <D.43655>:
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, falsebb);
        <D.43656>:
        <D.43650>:
        D.43297 = cfg->cbb;
        D.43297->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.43662>;
        <D.43642>:
        D.43297 = cfg->cbb;
        D.43297->extended = 1;
        <D.43662>:
        <D.43634>:
      }
      goto <D.43663>;
      <D.43599>:
      D.43520 = klass->cast_class;
      D.43532 = mono_defaults.enum_class;
      if (D.43520 == D.43532) goto <D.43664>; else goto <D.43665>;
      <D.43664>:
      D.43532 = mono_defaults.enum_class;
      mini_emit_class_check_branch (cfg, eclass_reg, D.43532, 551, is_null_bb);
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.43286 = cfg->mempool;
        ins = mono_mempool_alloc (D.43286, 80);
        ins->data.op[1].const_val = 0;
        D.43666 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.43666;
        ins->prev = 0B;
        D.43667 = ins->prev;
        ins->next = D.43667;
        ins->opcode = 442;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.43668 = ins->sreg3;
        ins->sreg2 = D.43668;
        D.43669 = ins->sreg2;
        ins->sreg1 = D.43669;
        D.43293 = cfg->ip;
        ins->cil_code = D.43293;
        if (1 != 0) goto <D.43670>; else goto <D.43671>;
        <D.43670>:
        D.43286 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.43286, 296);
        D.43303 = cfg->num_bblocks;
        D.43672 = D.43303;
        D.43673 = D.43672 + 1;
        cfg->num_bblocks = D.43673;
        D.43674 = (int) D.43672;
        falsebb->block_num = D.43674;
        ins->data.op[0].target_block = false_bb;
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, false_bb);
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 != 0B) goto <D.43675>; else goto <D.43676>;
        <D.43675>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43298->next = ins;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        ins->prev = D.43298;
        D.43297 = cfg->cbb;
        D.43297->last_ins = ins;
        goto <D.43677>;
        <D.43676>:
        D.43297 = cfg->cbb;
        D.43297 = cfg->cbb;
        D.43297->last_ins = ins;
        D.43298 = D.43297->last_ins;
        D.43297->code = D.43298;
        <D.43677>:
        D.43678 = falsebb->cil_code;
        if (D.43678 != 0B) goto <D.43679>; else goto <D.43680>;
        <D.43679>:
        D.43342 = cfg->cil_offset_to_bb;
        D.43678 = falsebb->cil_code;
        D.43681 = (long int) D.43678;
        D.43344 = cfg->cil_start;
        D.43345 = (long int) D.43344;
        D.43682 = D.43681 - D.43345;
        D.43683 = (long unsigned int) D.43682;
        D.43684 = D.43683 * 8;
        D.43685 = D.43342 + D.43684;
        *D.43685 = falsebb;
        <D.43680>:
        D.43350 = cfg->real_offset;
        falsebb->real_offset = D.43350;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 != 0B) goto <D.43689>; else goto <D.43686>;
        <D.43689>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43356 = D.43355 + 64985;
        if (D.43356 <= 9) goto <D.43687>; else goto <D.43690>;
        <D.43690>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43358 = D.43355 + 64878;
        if (D.43358 <= 9) goto <D.43687>; else goto <D.43691>;
        <D.43691>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43360 = D.43355 + 64888;
        if (D.43360 <= 9) goto <D.43687>; else goto <D.43686>;
        <D.43687>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43361 = D.43298->data.op[1].many_blocks;
        D.43362 = D.43361 + 8;
        D.43363 = *D.43362;
        if (D.43363 == 0B) goto <D.43692>; else goto <D.43686>;
        <D.43692>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43361 = D.43298->data.op[1].many_blocks;
        D.43362 = D.43361 + 8;
        *D.43362 = falsebb;
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, falsebb);
        goto <D.43688>;
        <D.43686>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 == 0B) goto <D.43693>; else goto <D.43695>;
        <D.43695>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        if (D.43355 != 442) goto <D.43696>; else goto <D.43694>;
        <D.43696>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        if (D.43355 != 759) goto <D.43697>; else goto <D.43694>;
        <D.43697>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43356 = D.43355 + 64985;
        if (D.43356 > 9) goto <D.43698>; else goto <D.43694>;
        <D.43698>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43358 = D.43355 + 64878;
        if (D.43358 > 9) goto <D.43699>; else goto <D.43694>;
        <D.43699>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43360 = D.43355 + 64888;
        if (D.43360 > 9) goto <D.43693>; else goto <D.43694>;
        <D.43693>:
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, falsebb);
        <D.43694>:
        <D.43688>:
        D.43297 = cfg->cbb;
        D.43297->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.43700>;
        <D.43671>:
        D.43286 = cfg->mempool;
        D.43701 = mono_mempool_alloc (D.43286, 16);
        ins->data.op[1].many_blocks = D.43701;
        D.43702 = ins->data.op[1].many_blocks;
        *D.43702 = false_bb;
        D.43702 = ins->data.op[1].many_blocks;
        D.43703 = D.43702 + 8;
        *D.43703 = 0B;
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, false_bb);
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 != 0B) goto <D.43704>; else goto <D.43705>;
        <D.43704>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43298->next = ins;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        ins->prev = D.43298;
        D.43297 = cfg->cbb;
        D.43297->last_ins = ins;
        goto <D.43706>;
        <D.43705>:
        D.43297 = cfg->cbb;
        D.43297 = cfg->cbb;
        D.43297->last_ins = ins;
        D.43298 = D.43297->last_ins;
        D.43297->code = D.43298;
        <D.43706>:
        D.43379 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.43380 = D.43379 & 268435456;
        if (D.43380 == 0) goto <D.43707>; else goto <D.43708>;
        <D.43707>:
        D.43286 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.43286, 296);
        D.43303 = cfg->num_bblocks;
        D.43709 = D.43303;
        D.43710 = D.43709 + 1;
        cfg->num_bblocks = D.43710;
        D.43711 = (int) D.43709;
        falsebb->block_num = D.43711;
        D.43702 = ins->data.op[1].many_blocks;
        D.43703 = D.43702 + 8;
        *D.43703 = falsebb;
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, falsebb);
        D.43678 = falsebb->cil_code;
        if (D.43678 != 0B) goto <D.43712>; else goto <D.43713>;
        <D.43712>:
        D.43342 = cfg->cil_offset_to_bb;
        D.43678 = falsebb->cil_code;
        D.43681 = (long int) D.43678;
        D.43344 = cfg->cil_start;
        D.43345 = (long int) D.43344;
        D.43682 = D.43681 - D.43345;
        D.43683 = (long unsigned int) D.43682;
        D.43684 = D.43683 * 8;
        D.43685 = D.43342 + D.43684;
        *D.43685 = falsebb;
        <D.43713>:
        D.43350 = cfg->real_offset;
        falsebb->real_offset = D.43350;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 != 0B) goto <D.43717>; else goto <D.43714>;
        <D.43717>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43356 = D.43355 + 64985;
        if (D.43356 <= 9) goto <D.43715>; else goto <D.43718>;
        <D.43718>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43358 = D.43355 + 64878;
        if (D.43358 <= 9) goto <D.43715>; else goto <D.43719>;
        <D.43719>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43360 = D.43355 + 64888;
        if (D.43360 <= 9) goto <D.43715>; else goto <D.43714>;
        <D.43715>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43361 = D.43298->data.op[1].many_blocks;
        D.43362 = D.43361 + 8;
        D.43363 = *D.43362;
        if (D.43363 == 0B) goto <D.43720>; else goto <D.43714>;
        <D.43720>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43361 = D.43298->data.op[1].many_blocks;
        D.43362 = D.43361 + 8;
        *D.43362 = falsebb;
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, falsebb);
        goto <D.43716>;
        <D.43714>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 == 0B) goto <D.43721>; else goto <D.43723>;
        <D.43723>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        if (D.43355 != 442) goto <D.43724>; else goto <D.43722>;
        <D.43724>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        if (D.43355 != 759) goto <D.43725>; else goto <D.43722>;
        <D.43725>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43356 = D.43355 + 64985;
        if (D.43356 > 9) goto <D.43726>; else goto <D.43722>;
        <D.43726>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43358 = D.43355 + 64878;
        if (D.43358 > 9) goto <D.43727>; else goto <D.43722>;
        <D.43727>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43355 = D.43298->opcode;
        D.43360 = D.43355 + 64888;
        if (D.43360 > 9) goto <D.43721>; else goto <D.43722>;
        <D.43721>:
        D.43297 = cfg->cbb;
        mono_link_bblock (cfg, D.43297, falsebb);
        <D.43722>:
        <D.43716>:
        D.43297 = cfg->cbb;
        D.43297->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.43728>;
        <D.43708>:
        D.43297 = cfg->cbb;
        D.43297->extended = 1;
        <D.43728>:
        <D.43700>:
      }
      goto <D.43729>;
      <D.43665>:
      D.43520 = klass->cast_class;
      D.43730 = D.43520->flags;
      D.43731 = D.43730 & 32;
      if (D.43731 != 0) goto <D.43732>; else goto <D.43733>;
      <D.43732>:
      D.43520 = klass->cast_class;
      mini_emit_iface_class_cast (cfg, eclass_reg, D.43520, false_bb, is_null_bb);
      goto <D.43734>;
      <D.43733>:
      D.43421 = klass->rank;
      if (D.43421 == 1) goto <D.43735>; else goto <D.43736>;
      <D.43735>:
      D.43737 = klass->byval_arg.type;
      if (D.43737 == 29) goto <D.43738>; else goto <D.43739>;
      <D.43738>:
      {
        int bounds_reg;

        D.43740 = alloc_preg (cfg);
        bounds_reg = (int) D.43740;
        {
          struct MonoInst * inst;

          D.43286 = cfg->mempool;
          inst = mono_mempool_alloc (D.43286, 80);
          inst->data.op[1].const_val = 0;
          D.43741 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.43741;
          inst->prev = 0B;
          D.43742 = inst->prev;
          inst->next = D.43742;
          inst->opcode = 388;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.43743 = inst->sreg3;
          inst->sreg2 = D.43743;
          D.43744 = inst->sreg2;
          inst->sreg1 = D.43744;
          D.43293 = cfg->ip;
          inst->cil_code = D.43293;
          inst->dreg = bounds_reg;
          inst->sreg1 = obj_reg;
          inst->data.op[0].const_val = 16;
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          if (D.43298 != 0B) goto <D.43745>; else goto <D.43746>;
          <D.43745>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43298->next = inst;
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          inst->prev = D.43298;
          D.43297 = cfg->cbb;
          D.43297->last_ins = inst;
          goto <D.43747>;
          <D.43746>:
          D.43297 = cfg->cbb;
          D.43297 = cfg->cbb;
          D.43297->last_ins = inst;
          D.43298 = D.43297->last_ins;
          D.43297->code = D.43298;
          <D.43747>:
        }
        {
          struct MonoInst * inst;

          D.43286 = cfg->mempool;
          inst = mono_mempool_alloc (D.43286, 80);
          inst->data.op[1].const_val = 0;
          D.43748 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.43748;
          inst->prev = 0B;
          D.43749 = inst->prev;
          inst->next = D.43749;
          inst->opcode = 323;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.43750 = inst->sreg3;
          inst->sreg2 = D.43750;
          D.43751 = inst->sreg2;
          inst->sreg1 = D.43751;
          D.43293 = cfg->ip;
          inst->cil_code = D.43293;
          inst->dreg = -1;
          inst->sreg1 = bounds_reg;
          inst->data.op[1].const_val = 0;
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          if (D.43298 != 0B) goto <D.43752>; else goto <D.43753>;
          <D.43752>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43298->next = inst;
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          inst->prev = D.43298;
          D.43297 = cfg->cbb;
          D.43297->last_ins = inst;
          goto <D.43754>;
          <D.43753>:
          D.43297 = cfg->cbb;
          D.43297 = cfg->cbb;
          D.43297->last_ins = inst;
          D.43298 = D.43297->last_ins;
          D.43297->code = D.43298;
          <D.43754>:
        }
        {
          struct MonoInst * ins;
          struct MonoBasicBlock * falsebb;

          D.43286 = cfg->mempool;
          ins = mono_mempool_alloc (D.43286, 80);
          ins->data.op[1].const_val = 0;
          D.43755 = ins->data.op[1].const_val;
          ins->data.op[0].const_val = D.43755;
          ins->prev = 0B;
          D.43756 = ins->prev;
          ins->next = D.43756;
          ins->opcode = 556;
          ins->flags = 0;
          ins->type = 0;
          ins->dreg = -1;
          ins->sreg3 = -1;
          D.43757 = ins->sreg3;
          ins->sreg2 = D.43757;
          D.43758 = ins->sreg2;
          ins->sreg1 = D.43758;
          D.43293 = cfg->ip;
          ins->cil_code = D.43293;
          if (0 != 0) goto <D.43759>; else goto <D.43760>;
          <D.43759>:
          D.43286 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.43286, 296);
          D.43303 = cfg->num_bblocks;
          D.43761 = D.43303;
          D.43762 = D.43761 + 1;
          cfg->num_bblocks = D.43762;
          D.43763 = (int) D.43761;
          falsebb->block_num = D.43763;
          ins->data.op[0].target_block = false_bb;
          D.43297 = cfg->cbb;
          mono_link_bblock (cfg, D.43297, false_bb);
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          if (D.43298 != 0B) goto <D.43764>; else goto <D.43765>;
          <D.43764>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43298->next = ins;
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          ins->prev = D.43298;
          D.43297 = cfg->cbb;
          D.43297->last_ins = ins;
          goto <D.43766>;
          <D.43765>:
          D.43297 = cfg->cbb;
          D.43297 = cfg->cbb;
          D.43297->last_ins = ins;
          D.43298 = D.43297->last_ins;
          D.43297->code = D.43298;
          <D.43766>:
          D.43767 = falsebb->cil_code;
          if (D.43767 != 0B) goto <D.43768>; else goto <D.43769>;
          <D.43768>:
          D.43342 = cfg->cil_offset_to_bb;
          D.43767 = falsebb->cil_code;
          D.43770 = (long int) D.43767;
          D.43344 = cfg->cil_start;
          D.43345 = (long int) D.43344;
          D.43771 = D.43770 - D.43345;
          D.43772 = (long unsigned int) D.43771;
          D.43773 = D.43772 * 8;
          D.43774 = D.43342 + D.43773;
          *D.43774 = falsebb;
          <D.43769>:
          D.43350 = cfg->real_offset;
          falsebb->real_offset = D.43350;
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          if (D.43298 != 0B) goto <D.43778>; else goto <D.43775>;
          <D.43778>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43356 = D.43355 + 64985;
          if (D.43356 <= 9) goto <D.43776>; else goto <D.43779>;
          <D.43779>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43358 = D.43355 + 64878;
          if (D.43358 <= 9) goto <D.43776>; else goto <D.43780>;
          <D.43780>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43360 = D.43355 + 64888;
          if (D.43360 <= 9) goto <D.43776>; else goto <D.43775>;
          <D.43776>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43361 = D.43298->data.op[1].many_blocks;
          D.43362 = D.43361 + 8;
          D.43363 = *D.43362;
          if (D.43363 == 0B) goto <D.43781>; else goto <D.43775>;
          <D.43781>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43361 = D.43298->data.op[1].many_blocks;
          D.43362 = D.43361 + 8;
          *D.43362 = falsebb;
          D.43297 = cfg->cbb;
          mono_link_bblock (cfg, D.43297, falsebb);
          goto <D.43777>;
          <D.43775>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          if (D.43298 == 0B) goto <D.43782>; else goto <D.43784>;
          <D.43784>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          if (D.43355 != 442) goto <D.43785>; else goto <D.43783>;
          <D.43785>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          if (D.43355 != 759) goto <D.43786>; else goto <D.43783>;
          <D.43786>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43356 = D.43355 + 64985;
          if (D.43356 > 9) goto <D.43787>; else goto <D.43783>;
          <D.43787>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43358 = D.43355 + 64878;
          if (D.43358 > 9) goto <D.43788>; else goto <D.43783>;
          <D.43788>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43360 = D.43355 + 64888;
          if (D.43360 > 9) goto <D.43782>; else goto <D.43783>;
          <D.43782>:
          D.43297 = cfg->cbb;
          mono_link_bblock (cfg, D.43297, falsebb);
          <D.43783>:
          <D.43777>:
          D.43297 = cfg->cbb;
          D.43297->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.43789>;
          <D.43760>:
          D.43286 = cfg->mempool;
          D.43790 = mono_mempool_alloc (D.43286, 16);
          ins->data.op[1].many_blocks = D.43790;
          D.43791 = ins->data.op[1].many_blocks;
          *D.43791 = false_bb;
          D.43791 = ins->data.op[1].many_blocks;
          D.43792 = D.43791 + 8;
          *D.43792 = 0B;
          D.43297 = cfg->cbb;
          mono_link_bblock (cfg, D.43297, false_bb);
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          if (D.43298 != 0B) goto <D.43793>; else goto <D.43794>;
          <D.43793>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43298->next = ins;
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          ins->prev = D.43298;
          D.43297 = cfg->cbb;
          D.43297->last_ins = ins;
          goto <D.43795>;
          <D.43794>:
          D.43297 = cfg->cbb;
          D.43297 = cfg->cbb;
          D.43297->last_ins = ins;
          D.43298 = D.43297->last_ins;
          D.43297->code = D.43298;
          <D.43795>:
          D.43379 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.43380 = D.43379 & 268435456;
          if (D.43380 == 0) goto <D.43796>; else goto <D.43797>;
          <D.43796>:
          D.43286 = cfg->mempool;
          falsebb = mono_mempool_alloc0 (D.43286, 296);
          D.43303 = cfg->num_bblocks;
          D.43798 = D.43303;
          D.43799 = D.43798 + 1;
          cfg->num_bblocks = D.43799;
          D.43800 = (int) D.43798;
          falsebb->block_num = D.43800;
          D.43791 = ins->data.op[1].many_blocks;
          D.43792 = D.43791 + 8;
          *D.43792 = falsebb;
          D.43297 = cfg->cbb;
          mono_link_bblock (cfg, D.43297, falsebb);
          D.43767 = falsebb->cil_code;
          if (D.43767 != 0B) goto <D.43801>; else goto <D.43802>;
          <D.43801>:
          D.43342 = cfg->cil_offset_to_bb;
          D.43767 = falsebb->cil_code;
          D.43770 = (long int) D.43767;
          D.43344 = cfg->cil_start;
          D.43345 = (long int) D.43344;
          D.43771 = D.43770 - D.43345;
          D.43772 = (long unsigned int) D.43771;
          D.43773 = D.43772 * 8;
          D.43774 = D.43342 + D.43773;
          *D.43774 = falsebb;
          <D.43802>:
          D.43350 = cfg->real_offset;
          falsebb->real_offset = D.43350;
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          if (D.43298 != 0B) goto <D.43806>; else goto <D.43803>;
          <D.43806>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43356 = D.43355 + 64985;
          if (D.43356 <= 9) goto <D.43804>; else goto <D.43807>;
          <D.43807>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43358 = D.43355 + 64878;
          if (D.43358 <= 9) goto <D.43804>; else goto <D.43808>;
          <D.43808>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43360 = D.43355 + 64888;
          if (D.43360 <= 9) goto <D.43804>; else goto <D.43803>;
          <D.43804>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43361 = D.43298->data.op[1].many_blocks;
          D.43362 = D.43361 + 8;
          D.43363 = *D.43362;
          if (D.43363 == 0B) goto <D.43809>; else goto <D.43803>;
          <D.43809>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43361 = D.43298->data.op[1].many_blocks;
          D.43362 = D.43361 + 8;
          *D.43362 = falsebb;
          D.43297 = cfg->cbb;
          mono_link_bblock (cfg, D.43297, falsebb);
          goto <D.43805>;
          <D.43803>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          if (D.43298 == 0B) goto <D.43810>; else goto <D.43812>;
          <D.43812>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          if (D.43355 != 442) goto <D.43813>; else goto <D.43811>;
          <D.43813>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          if (D.43355 != 759) goto <D.43814>; else goto <D.43811>;
          <D.43814>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43356 = D.43355 + 64985;
          if (D.43356 > 9) goto <D.43815>; else goto <D.43811>;
          <D.43815>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43358 = D.43355 + 64878;
          if (D.43358 > 9) goto <D.43816>; else goto <D.43811>;
          <D.43816>:
          D.43297 = cfg->cbb;
          D.43298 = D.43297->last_ins;
          D.43355 = D.43298->opcode;
          D.43360 = D.43355 + 64888;
          if (D.43360 > 9) goto <D.43810>; else goto <D.43811>;
          <D.43810>:
          D.43297 = cfg->cbb;
          mono_link_bblock (cfg, D.43297, falsebb);
          <D.43811>:
          <D.43805>:
          D.43297 = cfg->cbb;
          D.43297->next_bb = falsebb;
          cfg->cbb = falsebb;
          goto <D.43817>;
          <D.43797>:
          D.43297 = cfg->cbb;
          D.43297->extended = 1;
          <D.43817>:
          <D.43789>:
        }
      }
      <D.43739>:
      <D.43736>:
      D.43520 = klass->cast_class;
      mini_emit_isninst_cast (cfg, eclass_reg, D.43520, false_bb, is_null_bb);
      <D.43734>:
      <D.43729>:
      <D.43663>:
      <D.43597>:
    }
    goto <D.43818>;
    <D.43423>:
    D.43819 = mono_class_is_nullable (klass);
    if (D.43819 != 0) goto <D.43820>; else goto <D.43821>;
    <D.43820>:
    D.43414 = context_used != 0;
    D.43415 = (long int) D.43414;
    D.43416 = __builtin_expect (D.43415, 0);
    if (D.43416 != 0) goto <D.43822>; else goto <D.43823>;
    <D.43822>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4130, "!context_used");
    <D.43823>:
    {
      struct MonoInst * inst;

      D.43286 = cfg->mempool;
      inst = mono_mempool_alloc (D.43286, 80);
      inst->data.op[1].const_val = 0;
      D.43824 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.43824;
      inst->prev = 0B;
      D.43825 = inst->prev;
      inst->next = D.43825;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.43826 = inst->sreg3;
      inst->sreg2 = D.43826;
      D.43827 = inst->sreg2;
      inst->sreg1 = D.43827;
      D.43293 = cfg->ip;
      inst->cil_code = D.43293;
      inst->dreg = klass_reg;
      inst->sreg1 = vtable_reg;
      inst->data.op[0].const_val = 0;
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      if (D.43298 != 0B) goto <D.43828>; else goto <D.43829>;
      <D.43828>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43298->next = inst;
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      inst->prev = D.43298;
      D.43297 = cfg->cbb;
      D.43297->last_ins = inst;
      goto <D.43830>;
      <D.43829>:
      D.43297 = cfg->cbb;
      D.43297 = cfg->cbb;
      D.43297->last_ins = inst;
      D.43298 = D.43297->last_ins;
      D.43297->code = D.43298;
      <D.43830>:
    }
    D.43520 = klass->cast_class;
    mini_emit_isninst_cast (cfg, klass_reg, D.43520, false_bb, is_null_bb);
    goto <D.43831>;
    <D.43821>:
    D.43379 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.43834 = D.43379 & 33554432;
    if (D.43834 == 0) goto <D.43835>; else goto <D.43832>;
    <D.43835>:
    D.43836 = cfg->opt;
    D.43837 = D.43836 & 512;
    if (D.43837 == 0) goto <D.43838>; else goto <D.43832>;
    <D.43838>:
    D.43410 = klass->flags;
    D.43839 = D.43410 & 256;
    if (D.43839 != 0) goto <D.43840>; else goto <D.43832>;
    <D.43840>:
    D.43414 = context_used != 0;
    D.43415 = (long int) D.43414;
    D.43416 = __builtin_expect (D.43415, 0);
    if (D.43416 != 0) goto <D.43841>; else goto <D.43842>;
    <D.43841>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4136, "!context_used");
    <D.43842>:
    if (0 != 0) goto <D.43843>; else goto <D.43844>;
    <D.43843>:
    {
      struct MonoVTable * vt;

      D.43845 = cfg->domain;
      vt = mono_class_vtable (D.43845, klass);
      if (vt == 0B) goto <D.43846>; else goto <D.43847>;
      <D.43846>:
      mono_cfg_set_exception (cfg, 7);
      cfg->exception_ptr = klass;
      D.43302 = 0B;
      return D.43302;
      <D.43847>:
      {
        struct MonoInst * inst;

        D.43286 = cfg->mempool;
        inst = mono_mempool_alloc (D.43286, 80);
        inst->data.op[1].const_val = 0;
        D.43848 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.43848;
        inst->prev = 0B;
        D.43849 = inst->prev;
        inst->next = D.43849;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.43850 = inst->sreg3;
        inst->sreg2 = D.43850;
        D.43851 = inst->sreg2;
        inst->sreg1 = D.43851;
        D.43293 = cfg->ip;
        inst->cil_code = D.43293;
        inst->dreg = -1;
        inst->sreg1 = vtable_reg;
        vt.372 = (long int) vt;
        inst->data.op[1].const_val = vt.372;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        if (D.43298 != 0B) goto <D.43853>; else goto <D.43854>;
        <D.43853>:
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        D.43298->next = inst;
        D.43297 = cfg->cbb;
        D.43298 = D.43297->last_ins;
        inst->prev = D.43298;
        D.43297 = cfg->cbb;
        D.43297->last_ins = inst;
        goto <D.43855>;
        <D.43854>:
        D.43297 = cfg->cbb;
        D.43297 = cfg->cbb;
        D.43297->last_ins = inst;
        D.43298 = D.43297->last_ins;
        D.43297->code = D.43298;
        <D.43855>:
      }
    }
    goto <D.43856>;
    <D.43844>:
    {
      struct MonoInst * inst;

      D.43286 = cfg->mempool;
      inst = mono_mempool_alloc (D.43286, 80);
      inst->data.op[1].const_val = 0;
      D.43857 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.43857;
      inst->prev = 0B;
      D.43858 = inst->prev;
      inst->next = D.43858;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.43859 = inst->sreg3;
      inst->sreg2 = D.43859;
      D.43860 = inst->sreg2;
      inst->sreg1 = D.43860;
      D.43293 = cfg->ip;
      inst->cil_code = D.43293;
      inst->dreg = klass_reg;
      inst->sreg1 = vtable_reg;
      inst->data.op[0].const_val = 0;
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      if (D.43298 != 0B) goto <D.43861>; else goto <D.43862>;
      <D.43861>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43298->next = inst;
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      inst->prev = D.43298;
      D.43297 = cfg->cbb;
      D.43297->last_ins = inst;
      goto <D.43863>;
      <D.43862>:
      D.43297 = cfg->cbb;
      D.43297 = cfg->cbb;
      D.43297->last_ins = inst;
      D.43298 = D.43297->last_ins;
      D.43297->code = D.43298;
      <D.43863>:
    }
    {
      struct MonoInst * inst;

      D.43286 = cfg->mempool;
      inst = mono_mempool_alloc (D.43286, 80);
      inst->data.op[1].const_val = 0;
      D.43864 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.43864;
      inst->prev = 0B;
      D.43865 = inst->prev;
      inst->next = D.43865;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.43866 = inst->sreg3;
      inst->sreg2 = D.43866;
      D.43867 = inst->sreg2;
      inst->sreg1 = D.43867;
      D.43293 = cfg->ip;
      inst->cil_code = D.43293;
      inst->dreg = -1;
      inst->sreg1 = klass_reg;
      klass.373 = (long int) klass;
      inst->data.op[1].const_val = klass.373;
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      if (D.43298 != 0B) goto <D.43869>; else goto <D.43870>;
      <D.43869>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43298->next = inst;
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      inst->prev = D.43298;
      D.43297 = cfg->cbb;
      D.43297->last_ins = inst;
      goto <D.43871>;
      <D.43870>:
      D.43297 = cfg->cbb;
      D.43297 = cfg->cbb;
      D.43297->last_ins = inst;
      D.43298 = D.43297->last_ins;
      D.43297->code = D.43298;
      <D.43871>:
    }
    <D.43856>:
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.43286 = cfg->mempool;
      ins = mono_mempool_alloc (D.43286, 80);
      ins->data.op[1].const_val = 0;
      D.43872 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.43872;
      ins->prev = 0B;
      D.43873 = ins->prev;
      ins->next = D.43873;
      ins->opcode = 556;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.43874 = ins->sreg3;
      ins->sreg2 = D.43874;
      D.43875 = ins->sreg2;
      ins->sreg1 = D.43875;
      D.43293 = cfg->ip;
      ins->cil_code = D.43293;
      if (0 != 0) goto <D.43876>; else goto <D.43877>;
      <D.43876>:
      D.43286 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.43286, 296);
      D.43303 = cfg->num_bblocks;
      D.43878 = D.43303;
      D.43879 = D.43878 + 1;
      cfg->num_bblocks = D.43879;
      D.43880 = (int) D.43878;
      falsebb->block_num = D.43880;
      ins->data.op[0].target_block = false_bb;
      D.43297 = cfg->cbb;
      mono_link_bblock (cfg, D.43297, false_bb);
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      if (D.43298 != 0B) goto <D.43881>; else goto <D.43882>;
      <D.43881>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43298->next = ins;
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      ins->prev = D.43298;
      D.43297 = cfg->cbb;
      D.43297->last_ins = ins;
      goto <D.43883>;
      <D.43882>:
      D.43297 = cfg->cbb;
      D.43297 = cfg->cbb;
      D.43297->last_ins = ins;
      D.43298 = D.43297->last_ins;
      D.43297->code = D.43298;
      <D.43883>:
      D.43884 = falsebb->cil_code;
      if (D.43884 != 0B) goto <D.43885>; else goto <D.43886>;
      <D.43885>:
      D.43342 = cfg->cil_offset_to_bb;
      D.43884 = falsebb->cil_code;
      D.43887 = (long int) D.43884;
      D.43344 = cfg->cil_start;
      D.43345 = (long int) D.43344;
      D.43888 = D.43887 - D.43345;
      D.43889 = (long unsigned int) D.43888;
      D.43890 = D.43889 * 8;
      D.43891 = D.43342 + D.43890;
      *D.43891 = falsebb;
      <D.43886>:
      D.43350 = cfg->real_offset;
      falsebb->real_offset = D.43350;
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      if (D.43298 != 0B) goto <D.43895>; else goto <D.43892>;
      <D.43895>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43356 = D.43355 + 64985;
      if (D.43356 <= 9) goto <D.43893>; else goto <D.43896>;
      <D.43896>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43358 = D.43355 + 64878;
      if (D.43358 <= 9) goto <D.43893>; else goto <D.43897>;
      <D.43897>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43360 = D.43355 + 64888;
      if (D.43360 <= 9) goto <D.43893>; else goto <D.43892>;
      <D.43893>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43361 = D.43298->data.op[1].many_blocks;
      D.43362 = D.43361 + 8;
      D.43363 = *D.43362;
      if (D.43363 == 0B) goto <D.43898>; else goto <D.43892>;
      <D.43898>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43361 = D.43298->data.op[1].many_blocks;
      D.43362 = D.43361 + 8;
      *D.43362 = falsebb;
      D.43297 = cfg->cbb;
      mono_link_bblock (cfg, D.43297, falsebb);
      goto <D.43894>;
      <D.43892>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      if (D.43298 == 0B) goto <D.43899>; else goto <D.43901>;
      <D.43901>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      if (D.43355 != 442) goto <D.43902>; else goto <D.43900>;
      <D.43902>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      if (D.43355 != 759) goto <D.43903>; else goto <D.43900>;
      <D.43903>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43356 = D.43355 + 64985;
      if (D.43356 > 9) goto <D.43904>; else goto <D.43900>;
      <D.43904>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43358 = D.43355 + 64878;
      if (D.43358 > 9) goto <D.43905>; else goto <D.43900>;
      <D.43905>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43360 = D.43355 + 64888;
      if (D.43360 > 9) goto <D.43899>; else goto <D.43900>;
      <D.43899>:
      D.43297 = cfg->cbb;
      mono_link_bblock (cfg, D.43297, falsebb);
      <D.43900>:
      <D.43894>:
      D.43297 = cfg->cbb;
      D.43297->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.43906>;
      <D.43877>:
      D.43286 = cfg->mempool;
      D.43907 = mono_mempool_alloc (D.43286, 16);
      ins->data.op[1].many_blocks = D.43907;
      D.43908 = ins->data.op[1].many_blocks;
      *D.43908 = false_bb;
      D.43908 = ins->data.op[1].many_blocks;
      D.43909 = D.43908 + 8;
      *D.43909 = 0B;
      D.43297 = cfg->cbb;
      mono_link_bblock (cfg, D.43297, false_bb);
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      if (D.43298 != 0B) goto <D.43910>; else goto <D.43911>;
      <D.43910>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43298->next = ins;
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      ins->prev = D.43298;
      D.43297 = cfg->cbb;
      D.43297->last_ins = ins;
      goto <D.43912>;
      <D.43911>:
      D.43297 = cfg->cbb;
      D.43297 = cfg->cbb;
      D.43297->last_ins = ins;
      D.43298 = D.43297->last_ins;
      D.43297->code = D.43298;
      <D.43912>:
      D.43379 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.43380 = D.43379 & 268435456;
      if (D.43380 == 0) goto <D.43913>; else goto <D.43914>;
      <D.43913>:
      D.43286 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.43286, 296);
      D.43303 = cfg->num_bblocks;
      D.43915 = D.43303;
      D.43916 = D.43915 + 1;
      cfg->num_bblocks = D.43916;
      D.43917 = (int) D.43915;
      falsebb->block_num = D.43917;
      D.43908 = ins->data.op[1].many_blocks;
      D.43909 = D.43908 + 8;
      *D.43909 = falsebb;
      D.43297 = cfg->cbb;
      mono_link_bblock (cfg, D.43297, falsebb);
      D.43884 = falsebb->cil_code;
      if (D.43884 != 0B) goto <D.43918>; else goto <D.43919>;
      <D.43918>:
      D.43342 = cfg->cil_offset_to_bb;
      D.43884 = falsebb->cil_code;
      D.43887 = (long int) D.43884;
      D.43344 = cfg->cil_start;
      D.43345 = (long int) D.43344;
      D.43888 = D.43887 - D.43345;
      D.43889 = (long unsigned int) D.43888;
      D.43890 = D.43889 * 8;
      D.43891 = D.43342 + D.43890;
      *D.43891 = falsebb;
      <D.43919>:
      D.43350 = cfg->real_offset;
      falsebb->real_offset = D.43350;
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      if (D.43298 != 0B) goto <D.43923>; else goto <D.43920>;
      <D.43923>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43356 = D.43355 + 64985;
      if (D.43356 <= 9) goto <D.43921>; else goto <D.43924>;
      <D.43924>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43358 = D.43355 + 64878;
      if (D.43358 <= 9) goto <D.43921>; else goto <D.43925>;
      <D.43925>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43360 = D.43355 + 64888;
      if (D.43360 <= 9) goto <D.43921>; else goto <D.43920>;
      <D.43921>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43361 = D.43298->data.op[1].many_blocks;
      D.43362 = D.43361 + 8;
      D.43363 = *D.43362;
      if (D.43363 == 0B) goto <D.43926>; else goto <D.43920>;
      <D.43926>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43361 = D.43298->data.op[1].many_blocks;
      D.43362 = D.43361 + 8;
      *D.43362 = falsebb;
      D.43297 = cfg->cbb;
      mono_link_bblock (cfg, D.43297, falsebb);
      goto <D.43922>;
      <D.43920>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      if (D.43298 == 0B) goto <D.43927>; else goto <D.43929>;
      <D.43929>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      if (D.43355 != 442) goto <D.43930>; else goto <D.43928>;
      <D.43930>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      if (D.43355 != 759) goto <D.43931>; else goto <D.43928>;
      <D.43931>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43356 = D.43355 + 64985;
      if (D.43356 > 9) goto <D.43932>; else goto <D.43928>;
      <D.43932>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43358 = D.43355 + 64878;
      if (D.43358 > 9) goto <D.43933>; else goto <D.43928>;
      <D.43933>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43360 = D.43355 + 64888;
      if (D.43360 > 9) goto <D.43927>; else goto <D.43928>;
      <D.43927>:
      D.43297 = cfg->cbb;
      mono_link_bblock (cfg, D.43297, falsebb);
      <D.43928>:
      <D.43922>:
      D.43297 = cfg->cbb;
      D.43297->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.43934>;
      <D.43914>:
      D.43297 = cfg->cbb;
      D.43297->extended = 1;
      <D.43934>:
      <D.43906>:
    }
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.43286 = cfg->mempool;
      ins = mono_mempool_alloc (D.43286, 80);
      ins->data.op[1].const_val = 0;
      D.43935 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.43935;
      ins->prev = 0B;
      D.43936 = ins->prev;
      ins->next = D.43936;
      ins->opcode = 442;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.43937 = ins->sreg3;
      ins->sreg2 = D.43937;
      D.43938 = ins->sreg2;
      ins->sreg1 = D.43938;
      D.43293 = cfg->ip;
      ins->cil_code = D.43293;
      if (1 != 0) goto <D.43939>; else goto <D.43940>;
      <D.43939>:
      D.43286 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.43286, 296);
      D.43303 = cfg->num_bblocks;
      D.43941 = D.43303;
      D.43942 = D.43941 + 1;
      cfg->num_bblocks = D.43942;
      D.43943 = (int) D.43941;
      falsebb->block_num = D.43943;
      ins->data.op[0].target_block = is_null_bb;
      D.43297 = cfg->cbb;
      mono_link_bblock (cfg, D.43297, is_null_bb);
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      if (D.43298 != 0B) goto <D.43944>; else goto <D.43945>;
      <D.43944>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43298->next = ins;
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      ins->prev = D.43298;
      D.43297 = cfg->cbb;
      D.43297->last_ins = ins;
      goto <D.43946>;
      <D.43945>:
      D.43297 = cfg->cbb;
      D.43297 = cfg->cbb;
      D.43297->last_ins = ins;
      D.43298 = D.43297->last_ins;
      D.43297->code = D.43298;
      <D.43946>:
      D.43947 = falsebb->cil_code;
      if (D.43947 != 0B) goto <D.43948>; else goto <D.43949>;
      <D.43948>:
      D.43342 = cfg->cil_offset_to_bb;
      D.43947 = falsebb->cil_code;
      D.43950 = (long int) D.43947;
      D.43344 = cfg->cil_start;
      D.43345 = (long int) D.43344;
      D.43951 = D.43950 - D.43345;
      D.43952 = (long unsigned int) D.43951;
      D.43953 = D.43952 * 8;
      D.43954 = D.43342 + D.43953;
      *D.43954 = falsebb;
      <D.43949>:
      D.43350 = cfg->real_offset;
      falsebb->real_offset = D.43350;
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      if (D.43298 != 0B) goto <D.43958>; else goto <D.43955>;
      <D.43958>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43356 = D.43355 + 64985;
      if (D.43356 <= 9) goto <D.43956>; else goto <D.43959>;
      <D.43959>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43358 = D.43355 + 64878;
      if (D.43358 <= 9) goto <D.43956>; else goto <D.43960>;
      <D.43960>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43360 = D.43355 + 64888;
      if (D.43360 <= 9) goto <D.43956>; else goto <D.43955>;
      <D.43956>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43361 = D.43298->data.op[1].many_blocks;
      D.43362 = D.43361 + 8;
      D.43363 = *D.43362;
      if (D.43363 == 0B) goto <D.43961>; else goto <D.43955>;
      <D.43961>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43361 = D.43298->data.op[1].many_blocks;
      D.43362 = D.43361 + 8;
      *D.43362 = falsebb;
      D.43297 = cfg->cbb;
      mono_link_bblock (cfg, D.43297, falsebb);
      goto <D.43957>;
      <D.43955>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      if (D.43298 == 0B) goto <D.43962>; else goto <D.43964>;
      <D.43964>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      if (D.43355 != 442) goto <D.43965>; else goto <D.43963>;
      <D.43965>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      if (D.43355 != 759) goto <D.43966>; else goto <D.43963>;
      <D.43966>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43356 = D.43355 + 64985;
      if (D.43356 > 9) goto <D.43967>; else goto <D.43963>;
      <D.43967>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43358 = D.43355 + 64878;
      if (D.43358 > 9) goto <D.43968>; else goto <D.43963>;
      <D.43968>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43360 = D.43355 + 64888;
      if (D.43360 > 9) goto <D.43962>; else goto <D.43963>;
      <D.43962>:
      D.43297 = cfg->cbb;
      mono_link_bblock (cfg, D.43297, falsebb);
      <D.43963>:
      <D.43957>:
      D.43297 = cfg->cbb;
      D.43297->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.43969>;
      <D.43940>:
      D.43286 = cfg->mempool;
      D.43970 = mono_mempool_alloc (D.43286, 16);
      ins->data.op[1].many_blocks = D.43970;
      D.43971 = ins->data.op[1].many_blocks;
      *D.43971 = is_null_bb;
      D.43971 = ins->data.op[1].many_blocks;
      D.43972 = D.43971 + 8;
      *D.43972 = 0B;
      D.43297 = cfg->cbb;
      mono_link_bblock (cfg, D.43297, is_null_bb);
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      if (D.43298 != 0B) goto <D.43973>; else goto <D.43974>;
      <D.43973>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43298->next = ins;
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      ins->prev = D.43298;
      D.43297 = cfg->cbb;
      D.43297->last_ins = ins;
      goto <D.43975>;
      <D.43974>:
      D.43297 = cfg->cbb;
      D.43297 = cfg->cbb;
      D.43297->last_ins = ins;
      D.43298 = D.43297->last_ins;
      D.43297->code = D.43298;
      <D.43975>:
      D.43379 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.43380 = D.43379 & 268435456;
      if (D.43380 == 0) goto <D.43976>; else goto <D.43977>;
      <D.43976>:
      D.43286 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.43286, 296);
      D.43303 = cfg->num_bblocks;
      D.43978 = D.43303;
      D.43979 = D.43978 + 1;
      cfg->num_bblocks = D.43979;
      D.43980 = (int) D.43978;
      falsebb->block_num = D.43980;
      D.43971 = ins->data.op[1].many_blocks;
      D.43972 = D.43971 + 8;
      *D.43972 = falsebb;
      D.43297 = cfg->cbb;
      mono_link_bblock (cfg, D.43297, falsebb);
      D.43947 = falsebb->cil_code;
      if (D.43947 != 0B) goto <D.43981>; else goto <D.43982>;
      <D.43981>:
      D.43342 = cfg->cil_offset_to_bb;
      D.43947 = falsebb->cil_code;
      D.43950 = (long int) D.43947;
      D.43344 = cfg->cil_start;
      D.43345 = (long int) D.43344;
      D.43951 = D.43950 - D.43345;
      D.43952 = (long unsigned int) D.43951;
      D.43953 = D.43952 * 8;
      D.43954 = D.43342 + D.43953;
      *D.43954 = falsebb;
      <D.43982>:
      D.43350 = cfg->real_offset;
      falsebb->real_offset = D.43350;
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      if (D.43298 != 0B) goto <D.43986>; else goto <D.43983>;
      <D.43986>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43356 = D.43355 + 64985;
      if (D.43356 <= 9) goto <D.43984>; else goto <D.43987>;
      <D.43987>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43358 = D.43355 + 64878;
      if (D.43358 <= 9) goto <D.43984>; else goto <D.43988>;
      <D.43988>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43360 = D.43355 + 64888;
      if (D.43360 <= 9) goto <D.43984>; else goto <D.43983>;
      <D.43984>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43361 = D.43298->data.op[1].many_blocks;
      D.43362 = D.43361 + 8;
      D.43363 = *D.43362;
      if (D.43363 == 0B) goto <D.43989>; else goto <D.43983>;
      <D.43989>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43361 = D.43298->data.op[1].many_blocks;
      D.43362 = D.43361 + 8;
      *D.43362 = falsebb;
      D.43297 = cfg->cbb;
      mono_link_bblock (cfg, D.43297, falsebb);
      goto <D.43985>;
      <D.43983>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      if (D.43298 == 0B) goto <D.43990>; else goto <D.43992>;
      <D.43992>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      if (D.43355 != 442) goto <D.43993>; else goto <D.43991>;
      <D.43993>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      if (D.43355 != 759) goto <D.43994>; else goto <D.43991>;
      <D.43994>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43356 = D.43355 + 64985;
      if (D.43356 > 9) goto <D.43995>; else goto <D.43991>;
      <D.43995>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43358 = D.43355 + 64878;
      if (D.43358 > 9) goto <D.43996>; else goto <D.43991>;
      <D.43996>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43355 = D.43298->opcode;
      D.43360 = D.43355 + 64888;
      if (D.43360 > 9) goto <D.43990>; else goto <D.43991>;
      <D.43990>:
      D.43297 = cfg->cbb;
      mono_link_bblock (cfg, D.43297, falsebb);
      <D.43991>:
      <D.43985>:
      D.43297 = cfg->cbb;
      D.43297->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.43997>;
      <D.43977>:
      D.43297 = cfg->cbb;
      D.43297->extended = 1;
      <D.43997>:
      <D.43969>:
    }
    goto <D.43833>;
    <D.43832>:
    {
      struct MonoInst * inst;

      D.43286 = cfg->mempool;
      inst = mono_mempool_alloc (D.43286, 80);
      inst->data.op[1].const_val = 0;
      D.43998 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.43998;
      inst->prev = 0B;
      D.43999 = inst->prev;
      inst->next = D.43999;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.44000 = inst->sreg3;
      inst->sreg2 = D.44000;
      D.44001 = inst->sreg2;
      inst->sreg1 = D.44001;
      D.43293 = cfg->ip;
      inst->cil_code = D.43293;
      inst->dreg = klass_reg;
      inst->sreg1 = vtable_reg;
      inst->data.op[0].const_val = 0;
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      if (D.43298 != 0B) goto <D.44002>; else goto <D.44003>;
      <D.44002>:
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      D.43298->next = inst;
      D.43297 = cfg->cbb;
      D.43298 = D.43297->last_ins;
      inst->prev = D.43298;
      D.43297 = cfg->cbb;
      D.43297->last_ins = inst;
      goto <D.44004>;
      <D.44003>:
      D.43297 = cfg->cbb;
      D.43297 = cfg->cbb;
      D.43297->last_ins = inst;
      D.43298 = D.43297->last_ins;
      D.43297->code = D.43298;
      <D.44004>:
    }
    mini_emit_isninst_cast_inst (cfg, klass_reg, klass, klass_inst, false_bb, is_null_bb);
    <D.43833>:
    <D.43831>:
    <D.43818>:
  }
  <D.43419>:
  D.44005 = false_bb->cil_code;
  if (D.44005 != 0B) goto <D.44006>; else goto <D.44007>;
  <D.44006>:
  D.43342 = cfg->cil_offset_to_bb;
  D.44005 = false_bb->cil_code;
  D.44008 = (long int) D.44005;
  D.43344 = cfg->cil_start;
  D.43345 = (long int) D.43344;
  D.44009 = D.44008 - D.43345;
  D.44010 = (long unsigned int) D.44009;
  D.44011 = D.44010 * 8;
  D.44012 = D.43342 + D.44011;
  *D.44012 = false_bb;
  <D.44007>:
  D.43350 = cfg->real_offset;
  false_bb->real_offset = D.43350;
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  if (D.43298 != 0B) goto <D.44016>; else goto <D.44013>;
  <D.44016>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  D.43356 = D.43355 + 64985;
  if (D.43356 <= 9) goto <D.44014>; else goto <D.44017>;
  <D.44017>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  D.43358 = D.43355 + 64878;
  if (D.43358 <= 9) goto <D.44014>; else goto <D.44018>;
  <D.44018>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  D.43360 = D.43355 + 64888;
  if (D.43360 <= 9) goto <D.44014>; else goto <D.44013>;
  <D.44014>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43361 = D.43298->data.op[1].many_blocks;
  D.43362 = D.43361 + 8;
  D.43363 = *D.43362;
  if (D.43363 == 0B) goto <D.44019>; else goto <D.44013>;
  <D.44019>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43361 = D.43298->data.op[1].many_blocks;
  D.43362 = D.43361 + 8;
  *D.43362 = false_bb;
  D.43297 = cfg->cbb;
  mono_link_bblock (cfg, D.43297, false_bb);
  goto <D.44015>;
  <D.44013>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  if (D.43298 == 0B) goto <D.44020>; else goto <D.44022>;
  <D.44022>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  if (D.43355 != 442) goto <D.44023>; else goto <D.44021>;
  <D.44023>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  if (D.43355 != 759) goto <D.44024>; else goto <D.44021>;
  <D.44024>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  D.43356 = D.43355 + 64985;
  if (D.43356 > 9) goto <D.44025>; else goto <D.44021>;
  <D.44025>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  D.43358 = D.43355 + 64878;
  if (D.43358 > 9) goto <D.44026>; else goto <D.44021>;
  <D.44026>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  D.43360 = D.43355 + 64888;
  if (D.43360 > 9) goto <D.44020>; else goto <D.44021>;
  <D.44020>:
  D.43297 = cfg->cbb;
  mono_link_bblock (cfg, D.43297, false_bb);
  <D.44021>:
  <D.44015>:
  D.43297 = cfg->cbb;
  D.43297->next_bb = false_bb;
  cfg->cbb = false_bb;
  {
    struct MonoInst * inst;

    D.43286 = cfg->mempool;
    inst = mono_mempool_alloc (D.43286, 80);
    inst->data.op[1].const_val = 0;
    D.44027 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44027;
    inst->prev = 0B;
    D.44028 = inst->prev;
    inst->next = D.44028;
    inst->opcode = 363;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44029 = inst->sreg3;
    inst->sreg2 = D.44029;
    D.44030 = inst->sreg2;
    inst->sreg1 = D.44030;
    D.43293 = cfg->ip;
    inst->cil_code = D.43293;
    inst->dreg = res_reg;
    inst->data.op[0].p = 0B;
    inst->type = 3;
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    if (D.43298 != 0B) goto <D.44031>; else goto <D.44032>;
    <D.44031>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43298->next = inst;
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    inst->prev = D.43298;
    D.43297 = cfg->cbb;
    D.43297->last_ins = inst;
    goto <D.44033>;
    <D.44032>:
    D.43297 = cfg->cbb;
    D.43297 = cfg->cbb;
    D.43297->last_ins = inst;
    D.43298 = D.43297->last_ins;
    D.43297->code = D.43298;
    <D.44033>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.43286 = cfg->mempool;
    ins = mono_mempool_alloc (D.43286, 80);
    ins->data.op[1].const_val = 0;
    D.44034 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.44034;
    ins->prev = 0B;
    D.44035 = ins->prev;
    ins->next = D.44035;
    ins->opcode = 442;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.44036 = ins->sreg3;
    ins->sreg2 = D.44036;
    D.44037 = ins->sreg2;
    ins->sreg1 = D.44037;
    D.43293 = cfg->ip;
    ins->cil_code = D.43293;
    if (1 != 0) goto <D.44038>; else goto <D.44039>;
    <D.44038>:
    D.43286 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.43286, 296);
    D.43303 = cfg->num_bblocks;
    D.44040 = D.43303;
    D.44041 = D.44040 + 1;
    cfg->num_bblocks = D.44041;
    D.44042 = (int) D.44040;
    falsebb->block_num = D.44042;
    ins->data.op[0].target_block = end_bb;
    D.43297 = cfg->cbb;
    mono_link_bblock (cfg, D.43297, end_bb);
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    if (D.43298 != 0B) goto <D.44043>; else goto <D.44044>;
    <D.44043>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43298->next = ins;
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    ins->prev = D.43298;
    D.43297 = cfg->cbb;
    D.43297->last_ins = ins;
    goto <D.44045>;
    <D.44044>:
    D.43297 = cfg->cbb;
    D.43297 = cfg->cbb;
    D.43297->last_ins = ins;
    D.43298 = D.43297->last_ins;
    D.43297->code = D.43298;
    <D.44045>:
    D.44046 = falsebb->cil_code;
    if (D.44046 != 0B) goto <D.44047>; else goto <D.44048>;
    <D.44047>:
    D.43342 = cfg->cil_offset_to_bb;
    D.44046 = falsebb->cil_code;
    D.44049 = (long int) D.44046;
    D.43344 = cfg->cil_start;
    D.43345 = (long int) D.43344;
    D.44050 = D.44049 - D.43345;
    D.44051 = (long unsigned int) D.44050;
    D.44052 = D.44051 * 8;
    D.44053 = D.43342 + D.44052;
    *D.44053 = falsebb;
    <D.44048>:
    D.43350 = cfg->real_offset;
    falsebb->real_offset = D.43350;
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    if (D.43298 != 0B) goto <D.44057>; else goto <D.44054>;
    <D.44057>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43356 = D.43355 + 64985;
    if (D.43356 <= 9) goto <D.44055>; else goto <D.44058>;
    <D.44058>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43358 = D.43355 + 64878;
    if (D.43358 <= 9) goto <D.44055>; else goto <D.44059>;
    <D.44059>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43360 = D.43355 + 64888;
    if (D.43360 <= 9) goto <D.44055>; else goto <D.44054>;
    <D.44055>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43361 = D.43298->data.op[1].many_blocks;
    D.43362 = D.43361 + 8;
    D.43363 = *D.43362;
    if (D.43363 == 0B) goto <D.44060>; else goto <D.44054>;
    <D.44060>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43361 = D.43298->data.op[1].many_blocks;
    D.43362 = D.43361 + 8;
    *D.43362 = falsebb;
    D.43297 = cfg->cbb;
    mono_link_bblock (cfg, D.43297, falsebb);
    goto <D.44056>;
    <D.44054>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    if (D.43298 == 0B) goto <D.44061>; else goto <D.44063>;
    <D.44063>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    if (D.43355 != 442) goto <D.44064>; else goto <D.44062>;
    <D.44064>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    if (D.43355 != 759) goto <D.44065>; else goto <D.44062>;
    <D.44065>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43356 = D.43355 + 64985;
    if (D.43356 > 9) goto <D.44066>; else goto <D.44062>;
    <D.44066>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43358 = D.43355 + 64878;
    if (D.43358 > 9) goto <D.44067>; else goto <D.44062>;
    <D.44067>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43360 = D.43355 + 64888;
    if (D.43360 > 9) goto <D.44061>; else goto <D.44062>;
    <D.44061>:
    D.43297 = cfg->cbb;
    mono_link_bblock (cfg, D.43297, falsebb);
    <D.44062>:
    <D.44056>:
    D.43297 = cfg->cbb;
    D.43297->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.44068>;
    <D.44039>:
    D.43286 = cfg->mempool;
    D.44069 = mono_mempool_alloc (D.43286, 16);
    ins->data.op[1].many_blocks = D.44069;
    D.44070 = ins->data.op[1].many_blocks;
    *D.44070 = end_bb;
    D.44070 = ins->data.op[1].many_blocks;
    D.44071 = D.44070 + 8;
    *D.44071 = 0B;
    D.43297 = cfg->cbb;
    mono_link_bblock (cfg, D.43297, end_bb);
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    if (D.43298 != 0B) goto <D.44072>; else goto <D.44073>;
    <D.44072>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43298->next = ins;
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    ins->prev = D.43298;
    D.43297 = cfg->cbb;
    D.43297->last_ins = ins;
    goto <D.44074>;
    <D.44073>:
    D.43297 = cfg->cbb;
    D.43297 = cfg->cbb;
    D.43297->last_ins = ins;
    D.43298 = D.43297->last_ins;
    D.43297->code = D.43298;
    <D.44074>:
    D.43379 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.43380 = D.43379 & 268435456;
    if (D.43380 == 0) goto <D.44075>; else goto <D.44076>;
    <D.44075>:
    D.43286 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.43286, 296);
    D.43303 = cfg->num_bblocks;
    D.44077 = D.43303;
    D.44078 = D.44077 + 1;
    cfg->num_bblocks = D.44078;
    D.44079 = (int) D.44077;
    falsebb->block_num = D.44079;
    D.44070 = ins->data.op[1].many_blocks;
    D.44071 = D.44070 + 8;
    *D.44071 = falsebb;
    D.43297 = cfg->cbb;
    mono_link_bblock (cfg, D.43297, falsebb);
    D.44046 = falsebb->cil_code;
    if (D.44046 != 0B) goto <D.44080>; else goto <D.44081>;
    <D.44080>:
    D.43342 = cfg->cil_offset_to_bb;
    D.44046 = falsebb->cil_code;
    D.44049 = (long int) D.44046;
    D.43344 = cfg->cil_start;
    D.43345 = (long int) D.43344;
    D.44050 = D.44049 - D.43345;
    D.44051 = (long unsigned int) D.44050;
    D.44052 = D.44051 * 8;
    D.44053 = D.43342 + D.44052;
    *D.44053 = falsebb;
    <D.44081>:
    D.43350 = cfg->real_offset;
    falsebb->real_offset = D.43350;
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    if (D.43298 != 0B) goto <D.44085>; else goto <D.44082>;
    <D.44085>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43356 = D.43355 + 64985;
    if (D.43356 <= 9) goto <D.44083>; else goto <D.44086>;
    <D.44086>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43358 = D.43355 + 64878;
    if (D.43358 <= 9) goto <D.44083>; else goto <D.44087>;
    <D.44087>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43360 = D.43355 + 64888;
    if (D.43360 <= 9) goto <D.44083>; else goto <D.44082>;
    <D.44083>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43361 = D.43298->data.op[1].many_blocks;
    D.43362 = D.43361 + 8;
    D.43363 = *D.43362;
    if (D.43363 == 0B) goto <D.44088>; else goto <D.44082>;
    <D.44088>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43361 = D.43298->data.op[1].many_blocks;
    D.43362 = D.43361 + 8;
    *D.43362 = falsebb;
    D.43297 = cfg->cbb;
    mono_link_bblock (cfg, D.43297, falsebb);
    goto <D.44084>;
    <D.44082>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    if (D.43298 == 0B) goto <D.44089>; else goto <D.44091>;
    <D.44091>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    if (D.43355 != 442) goto <D.44092>; else goto <D.44090>;
    <D.44092>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    if (D.43355 != 759) goto <D.44093>; else goto <D.44090>;
    <D.44093>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43356 = D.43355 + 64985;
    if (D.43356 > 9) goto <D.44094>; else goto <D.44090>;
    <D.44094>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43358 = D.43355 + 64878;
    if (D.43358 > 9) goto <D.44095>; else goto <D.44090>;
    <D.44095>:
    D.43297 = cfg->cbb;
    D.43298 = D.43297->last_ins;
    D.43355 = D.43298->opcode;
    D.43360 = D.43355 + 64888;
    if (D.43360 > 9) goto <D.44089>; else goto <D.44090>;
    <D.44089>:
    D.43297 = cfg->cbb;
    mono_link_bblock (cfg, D.43297, falsebb);
    <D.44090>:
    <D.44084>:
    D.43297 = cfg->cbb;
    D.43297->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.44096>;
    <D.44076>:
    D.43297 = cfg->cbb;
    D.43297->extended = 1;
    <D.44096>:
    <D.44068>:
  }
  D.44097 = is_null_bb->cil_code;
  if (D.44097 != 0B) goto <D.44098>; else goto <D.44099>;
  <D.44098>:
  D.43342 = cfg->cil_offset_to_bb;
  D.44097 = is_null_bb->cil_code;
  D.44100 = (long int) D.44097;
  D.43344 = cfg->cil_start;
  D.43345 = (long int) D.43344;
  D.44101 = D.44100 - D.43345;
  D.44102 = (long unsigned int) D.44101;
  D.44103 = D.44102 * 8;
  D.44104 = D.43342 + D.44103;
  *D.44104 = is_null_bb;
  <D.44099>:
  D.43350 = cfg->real_offset;
  is_null_bb->real_offset = D.43350;
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  if (D.43298 != 0B) goto <D.44108>; else goto <D.44105>;
  <D.44108>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  D.43356 = D.43355 + 64985;
  if (D.43356 <= 9) goto <D.44106>; else goto <D.44109>;
  <D.44109>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  D.43358 = D.43355 + 64878;
  if (D.43358 <= 9) goto <D.44106>; else goto <D.44110>;
  <D.44110>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  D.43360 = D.43355 + 64888;
  if (D.43360 <= 9) goto <D.44106>; else goto <D.44105>;
  <D.44106>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43361 = D.43298->data.op[1].many_blocks;
  D.43362 = D.43361 + 8;
  D.43363 = *D.43362;
  if (D.43363 == 0B) goto <D.44111>; else goto <D.44105>;
  <D.44111>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43361 = D.43298->data.op[1].many_blocks;
  D.43362 = D.43361 + 8;
  *D.43362 = is_null_bb;
  D.43297 = cfg->cbb;
  mono_link_bblock (cfg, D.43297, is_null_bb);
  goto <D.44107>;
  <D.44105>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  if (D.43298 == 0B) goto <D.44112>; else goto <D.44114>;
  <D.44114>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  if (D.43355 != 442) goto <D.44115>; else goto <D.44113>;
  <D.44115>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  if (D.43355 != 759) goto <D.44116>; else goto <D.44113>;
  <D.44116>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  D.43356 = D.43355 + 64985;
  if (D.43356 > 9) goto <D.44117>; else goto <D.44113>;
  <D.44117>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  D.43358 = D.43355 + 64878;
  if (D.43358 > 9) goto <D.44118>; else goto <D.44113>;
  <D.44118>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  D.43360 = D.43355 + 64888;
  if (D.43360 > 9) goto <D.44112>; else goto <D.44113>;
  <D.44112>:
  D.43297 = cfg->cbb;
  mono_link_bblock (cfg, D.43297, is_null_bb);
  <D.44113>:
  <D.44107>:
  D.43297 = cfg->cbb;
  D.43297->next_bb = is_null_bb;
  cfg->cbb = is_null_bb;
  D.44119 = end_bb->cil_code;
  if (D.44119 != 0B) goto <D.44120>; else goto <D.44121>;
  <D.44120>:
  D.43342 = cfg->cil_offset_to_bb;
  D.44119 = end_bb->cil_code;
  D.44122 = (long int) D.44119;
  D.43344 = cfg->cil_start;
  D.43345 = (long int) D.43344;
  D.44123 = D.44122 - D.43345;
  D.44124 = (long unsigned int) D.44123;
  D.44125 = D.44124 * 8;
  D.44126 = D.43342 + D.44125;
  *D.44126 = end_bb;
  <D.44121>:
  D.43350 = cfg->real_offset;
  end_bb->real_offset = D.43350;
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  if (D.43298 != 0B) goto <D.44130>; else goto <D.44127>;
  <D.44130>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  D.43356 = D.43355 + 64985;
  if (D.43356 <= 9) goto <D.44128>; else goto <D.44131>;
  <D.44131>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  D.43358 = D.43355 + 64878;
  if (D.43358 <= 9) goto <D.44128>; else goto <D.44132>;
  <D.44132>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  D.43360 = D.43355 + 64888;
  if (D.43360 <= 9) goto <D.44128>; else goto <D.44127>;
  <D.44128>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43361 = D.43298->data.op[1].many_blocks;
  D.43362 = D.43361 + 8;
  D.43363 = *D.43362;
  if (D.43363 == 0B) goto <D.44133>; else goto <D.44127>;
  <D.44133>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43361 = D.43298->data.op[1].many_blocks;
  D.43362 = D.43361 + 8;
  *D.43362 = end_bb;
  D.43297 = cfg->cbb;
  mono_link_bblock (cfg, D.43297, end_bb);
  goto <D.44129>;
  <D.44127>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  if (D.43298 == 0B) goto <D.44134>; else goto <D.44136>;
  <D.44136>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  if (D.43355 != 442) goto <D.44137>; else goto <D.44135>;
  <D.44137>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  if (D.43355 != 759) goto <D.44138>; else goto <D.44135>;
  <D.44138>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  D.43356 = D.43355 + 64985;
  if (D.43356 > 9) goto <D.44139>; else goto <D.44135>;
  <D.44139>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  D.43358 = D.43355 + 64878;
  if (D.43358 > 9) goto <D.44140>; else goto <D.44135>;
  <D.44140>:
  D.43297 = cfg->cbb;
  D.43298 = D.43297->last_ins;
  D.43355 = D.43298->opcode;
  D.43360 = D.43355 + 64888;
  if (D.43360 > 9) goto <D.44134>; else goto <D.44135>;
  <D.44134>:
  D.43297 = cfg->cbb;
  mono_link_bblock (cfg, D.43297, end_bb);
  <D.44135>:
  <D.44129>:
  D.43297 = cfg->cbb;
  D.43297->next_bb = end_bb;
  cfg->cbb = end_bb;
  D.43302 = ins;
  return D.43302;
}


mini_emit_iface_cast (struct MonoCompile * cfg, int vtable_reg, struct MonoClass * klass, struct MonoBasicBlock * false_target, struct MonoBasicBlock * true_target)
{
  unsigned int D.44144;
  struct MonoMemPool * D.44145;
  long int D.44146;
  struct MonoInst * D.44147;
  int D.44148;
  int D.44149;
  const unsigned char * D.44150;
  struct MonoBasicBlock * D.44151;
  struct MonoInst * D.44152;
  long int D.44158;
  struct MonoInst * D.44159;
  int D.44160;
  int D.44161;
  unsigned int D.44164;
  unsigned int D.44165;
  unsigned int D.44166;
  int D.44167;
  unsigned char * D.44171;
  struct MonoBasicBlock * * D.44174;
  long int D.44175;
  unsigned char * D.44176;
  long int D.44177;
  long int D.44178;
  long unsigned int D.44179;
  long unsigned int D.44180;
  struct MonoBasicBlock * * D.44181;
  unsigned int D.44182;
  short unsigned int D.44187;
  short unsigned int D.44188;
  short unsigned int D.44190;
  short unsigned int D.44192;
  struct MonoBasicBlock * * D.44193;
  struct MonoBasicBlock * * D.44194;
  struct MonoBasicBlock * D.44195;
  void * D.44205;
  struct MonoBasicBlock * * D.44206;
  struct MonoBasicBlock * * D.44207;
  long unsigned int D.44211;
  long unsigned int D.44212;
  unsigned int D.44215;
  unsigned int D.44216;
  int D.44217;
  long int D.44236;
  struct MonoInst * D.44237;
  int D.44238;
  int D.44239;
  int intf_reg;

  D.44144 = alloc_preg (cfg);
  intf_reg = (int) D.44144;
  mini_emit_max_iid_check_vtable (cfg, vtable_reg, klass, false_target);
  mini_emit_load_intf_bit_reg_vtable (cfg, intf_reg, vtable_reg, klass);
  {
    struct MonoInst * inst;

    D.44145 = cfg->mempool;
    inst = mono_mempool_alloc (D.44145, 80);
    inst->data.op[1].const_val = 0;
    D.44146 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44146;
    inst->prev = 0B;
    D.44147 = inst->prev;
    inst->next = D.44147;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44148 = inst->sreg3;
    inst->sreg2 = D.44148;
    D.44149 = inst->sreg2;
    inst->sreg1 = D.44149;
    D.44150 = cfg->ip;
    inst->cil_code = D.44150;
    inst->dreg = -1;
    inst->sreg1 = intf_reg;
    inst->data.op[1].const_val = 0;
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    if (D.44152 != 0B) goto <D.44153>; else goto <D.44154>;
    <D.44153>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44152->next = inst;
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    inst->prev = D.44152;
    D.44151 = cfg->cbb;
    D.44151->last_ins = inst;
    goto <D.44155>;
    <D.44154>:
    D.44151 = cfg->cbb;
    D.44151 = cfg->cbb;
    D.44151->last_ins = inst;
    D.44152 = D.44151->last_ins;
    D.44151->code = D.44152;
    <D.44155>:
  }
  if (true_target != 0B) goto <D.44156>; else goto <D.44157>;
  <D.44156>:
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.44145 = cfg->mempool;
    ins = mono_mempool_alloc (D.44145, 80);
    ins->data.op[1].const_val = 0;
    D.44158 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.44158;
    ins->prev = 0B;
    D.44159 = ins->prev;
    ins->next = D.44159;
    ins->opcode = 556;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.44160 = ins->sreg3;
    ins->sreg2 = D.44160;
    D.44161 = ins->sreg2;
    ins->sreg1 = D.44161;
    D.44150 = cfg->ip;
    ins->cil_code = D.44150;
    if (0 != 0) goto <D.44162>; else goto <D.44163>;
    <D.44162>:
    D.44145 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.44145, 296);
    D.44164 = cfg->num_bblocks;
    D.44165 = D.44164;
    D.44166 = D.44165 + 1;
    cfg->num_bblocks = D.44166;
    D.44167 = (int) D.44165;
    falsebb->block_num = D.44167;
    ins->data.op[0].target_block = true_target;
    D.44151 = cfg->cbb;
    mono_link_bblock (cfg, D.44151, true_target);
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    if (D.44152 != 0B) goto <D.44168>; else goto <D.44169>;
    <D.44168>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44152->next = ins;
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    ins->prev = D.44152;
    D.44151 = cfg->cbb;
    D.44151->last_ins = ins;
    goto <D.44170>;
    <D.44169>:
    D.44151 = cfg->cbb;
    D.44151 = cfg->cbb;
    D.44151->last_ins = ins;
    D.44152 = D.44151->last_ins;
    D.44151->code = D.44152;
    <D.44170>:
    D.44171 = falsebb->cil_code;
    if (D.44171 != 0B) goto <D.44172>; else goto <D.44173>;
    <D.44172>:
    D.44174 = cfg->cil_offset_to_bb;
    D.44171 = falsebb->cil_code;
    D.44175 = (long int) D.44171;
    D.44176 = cfg->cil_start;
    D.44177 = (long int) D.44176;
    D.44178 = D.44175 - D.44177;
    D.44179 = (long unsigned int) D.44178;
    D.44180 = D.44179 * 8;
    D.44181 = D.44174 + D.44180;
    *D.44181 = falsebb;
    <D.44173>:
    D.44182 = cfg->real_offset;
    falsebb->real_offset = D.44182;
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    if (D.44152 != 0B) goto <D.44186>; else goto <D.44183>;
    <D.44186>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44187 = D.44152->opcode;
    D.44188 = D.44187 + 64985;
    if (D.44188 <= 9) goto <D.44184>; else goto <D.44189>;
    <D.44189>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44187 = D.44152->opcode;
    D.44190 = D.44187 + 64878;
    if (D.44190 <= 9) goto <D.44184>; else goto <D.44191>;
    <D.44191>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44187 = D.44152->opcode;
    D.44192 = D.44187 + 64888;
    if (D.44192 <= 9) goto <D.44184>; else goto <D.44183>;
    <D.44184>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44193 = D.44152->data.op[1].many_blocks;
    D.44194 = D.44193 + 8;
    D.44195 = *D.44194;
    if (D.44195 == 0B) goto <D.44196>; else goto <D.44183>;
    <D.44196>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44193 = D.44152->data.op[1].many_blocks;
    D.44194 = D.44193 + 8;
    *D.44194 = falsebb;
    D.44151 = cfg->cbb;
    mono_link_bblock (cfg, D.44151, falsebb);
    goto <D.44185>;
    <D.44183>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    if (D.44152 == 0B) goto <D.44197>; else goto <D.44199>;
    <D.44199>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44187 = D.44152->opcode;
    if (D.44187 != 442) goto <D.44200>; else goto <D.44198>;
    <D.44200>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44187 = D.44152->opcode;
    if (D.44187 != 759) goto <D.44201>; else goto <D.44198>;
    <D.44201>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44187 = D.44152->opcode;
    D.44188 = D.44187 + 64985;
    if (D.44188 > 9) goto <D.44202>; else goto <D.44198>;
    <D.44202>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44187 = D.44152->opcode;
    D.44190 = D.44187 + 64878;
    if (D.44190 > 9) goto <D.44203>; else goto <D.44198>;
    <D.44203>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44187 = D.44152->opcode;
    D.44192 = D.44187 + 64888;
    if (D.44192 > 9) goto <D.44197>; else goto <D.44198>;
    <D.44197>:
    D.44151 = cfg->cbb;
    mono_link_bblock (cfg, D.44151, falsebb);
    <D.44198>:
    <D.44185>:
    D.44151 = cfg->cbb;
    D.44151->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.44204>;
    <D.44163>:
    D.44145 = cfg->mempool;
    D.44205 = mono_mempool_alloc (D.44145, 16);
    ins->data.op[1].many_blocks = D.44205;
    D.44206 = ins->data.op[1].many_blocks;
    *D.44206 = true_target;
    D.44206 = ins->data.op[1].many_blocks;
    D.44207 = D.44206 + 8;
    *D.44207 = 0B;
    D.44151 = cfg->cbb;
    mono_link_bblock (cfg, D.44151, true_target);
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    if (D.44152 != 0B) goto <D.44208>; else goto <D.44209>;
    <D.44208>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44152->next = ins;
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    ins->prev = D.44152;
    D.44151 = cfg->cbb;
    D.44151->last_ins = ins;
    goto <D.44210>;
    <D.44209>:
    D.44151 = cfg->cbb;
    D.44151 = cfg->cbb;
    D.44151->last_ins = ins;
    D.44152 = D.44151->last_ins;
    D.44151->code = D.44152;
    <D.44210>:
    D.44211 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.44212 = D.44211 & 268435456;
    if (D.44212 == 0) goto <D.44213>; else goto <D.44214>;
    <D.44213>:
    D.44145 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.44145, 296);
    D.44164 = cfg->num_bblocks;
    D.44215 = D.44164;
    D.44216 = D.44215 + 1;
    cfg->num_bblocks = D.44216;
    D.44217 = (int) D.44215;
    falsebb->block_num = D.44217;
    D.44206 = ins->data.op[1].many_blocks;
    D.44207 = D.44206 + 8;
    *D.44207 = falsebb;
    D.44151 = cfg->cbb;
    mono_link_bblock (cfg, D.44151, falsebb);
    D.44171 = falsebb->cil_code;
    if (D.44171 != 0B) goto <D.44218>; else goto <D.44219>;
    <D.44218>:
    D.44174 = cfg->cil_offset_to_bb;
    D.44171 = falsebb->cil_code;
    D.44175 = (long int) D.44171;
    D.44176 = cfg->cil_start;
    D.44177 = (long int) D.44176;
    D.44178 = D.44175 - D.44177;
    D.44179 = (long unsigned int) D.44178;
    D.44180 = D.44179 * 8;
    D.44181 = D.44174 + D.44180;
    *D.44181 = falsebb;
    <D.44219>:
    D.44182 = cfg->real_offset;
    falsebb->real_offset = D.44182;
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    if (D.44152 != 0B) goto <D.44223>; else goto <D.44220>;
    <D.44223>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44187 = D.44152->opcode;
    D.44188 = D.44187 + 64985;
    if (D.44188 <= 9) goto <D.44221>; else goto <D.44224>;
    <D.44224>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44187 = D.44152->opcode;
    D.44190 = D.44187 + 64878;
    if (D.44190 <= 9) goto <D.44221>; else goto <D.44225>;
    <D.44225>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44187 = D.44152->opcode;
    D.44192 = D.44187 + 64888;
    if (D.44192 <= 9) goto <D.44221>; else goto <D.44220>;
    <D.44221>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44193 = D.44152->data.op[1].many_blocks;
    D.44194 = D.44193 + 8;
    D.44195 = *D.44194;
    if (D.44195 == 0B) goto <D.44226>; else goto <D.44220>;
    <D.44226>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44193 = D.44152->data.op[1].many_blocks;
    D.44194 = D.44193 + 8;
    *D.44194 = falsebb;
    D.44151 = cfg->cbb;
    mono_link_bblock (cfg, D.44151, falsebb);
    goto <D.44222>;
    <D.44220>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    if (D.44152 == 0B) goto <D.44227>; else goto <D.44229>;
    <D.44229>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44187 = D.44152->opcode;
    if (D.44187 != 442) goto <D.44230>; else goto <D.44228>;
    <D.44230>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44187 = D.44152->opcode;
    if (D.44187 != 759) goto <D.44231>; else goto <D.44228>;
    <D.44231>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44187 = D.44152->opcode;
    D.44188 = D.44187 + 64985;
    if (D.44188 > 9) goto <D.44232>; else goto <D.44228>;
    <D.44232>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44187 = D.44152->opcode;
    D.44190 = D.44187 + 64878;
    if (D.44190 > 9) goto <D.44233>; else goto <D.44228>;
    <D.44233>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44187 = D.44152->opcode;
    D.44192 = D.44187 + 64888;
    if (D.44192 > 9) goto <D.44227>; else goto <D.44228>;
    <D.44227>:
    D.44151 = cfg->cbb;
    mono_link_bblock (cfg, D.44151, falsebb);
    <D.44228>:
    <D.44222>:
    D.44151 = cfg->cbb;
    D.44151->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.44234>;
    <D.44214>:
    D.44151 = cfg->cbb;
    D.44151->extended = 1;
    <D.44234>:
    <D.44204>:
  }
  goto <D.44235>;
  <D.44157>:
  {
    struct MonoInst * inst;

    D.44145 = cfg->mempool;
    inst = mono_mempool_alloc (D.44145, 80);
    inst->data.op[1].const_val = 0;
    D.44236 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44236;
    inst->prev = 0B;
    D.44237 = inst->prev;
    inst->next = D.44237;
    inst->opcode = 451;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44238 = inst->sreg3;
    inst->sreg2 = D.44238;
    D.44239 = inst->sreg2;
    inst->sreg1 = D.44239;
    D.44150 = cfg->ip;
    inst->cil_code = D.44150;
    inst->data.op[1].p = "InvalidCastException";
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    if (D.44152 != 0B) goto <D.44240>; else goto <D.44241>;
    <D.44240>:
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    D.44152->next = inst;
    D.44151 = cfg->cbb;
    D.44152 = D.44151->last_ins;
    inst->prev = D.44152;
    D.44151 = cfg->cbb;
    D.44151->last_ins = inst;
    goto <D.44242>;
    <D.44241>:
    D.44151 = cfg->cbb;
    D.44151 = cfg->cbb;
    D.44151->last_ins = inst;
    D.44152 = D.44151->last_ins;
    D.44151->code = D.44152;
    <D.44242>:
  }
  <D.44235>:
}


mini_emit_max_iid_check_vtable (struct MonoCompile * cfg, int vtable_reg, struct MonoClass * klass, struct MonoBasicBlock * false_target)
{
  unsigned int D.44243;
  struct MonoMemPool * D.44244;
  long int D.44245;
  struct MonoInst * D.44246;
  int D.44247;
  int D.44248;
  const unsigned char * D.44249;
  struct MonoBasicBlock * D.44250;
  struct MonoInst * D.44251;
  int max_iid_reg;

  D.44243 = alloc_preg (cfg);
  max_iid_reg = (int) D.44243;
  {
    struct MonoInst * inst;

    D.44244 = cfg->mempool;
    inst = mono_mempool_alloc (D.44244, 80);
    inst->data.op[1].const_val = 0;
    D.44245 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44245;
    inst->prev = 0B;
    D.44246 = inst->prev;
    inst->next = D.44246;
    inst->opcode = 392;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44247 = inst->sreg3;
    inst->sreg2 = D.44247;
    D.44248 = inst->sreg2;
    inst->sreg1 = D.44248;
    D.44249 = cfg->ip;
    inst->cil_code = D.44249;
    inst->dreg = max_iid_reg;
    inst->sreg1 = vtable_reg;
    inst->data.op[0].const_val = 40;
    D.44250 = cfg->cbb;
    D.44251 = D.44250->last_ins;
    if (D.44251 != 0B) goto <D.44252>; else goto <D.44253>;
    <D.44252>:
    D.44250 = cfg->cbb;
    D.44251 = D.44250->last_ins;
    D.44251->next = inst;
    D.44250 = cfg->cbb;
    D.44251 = D.44250->last_ins;
    inst->prev = D.44251;
    D.44250 = cfg->cbb;
    D.44250->last_ins = inst;
    goto <D.44254>;
    <D.44253>:
    D.44250 = cfg->cbb;
    D.44250 = cfg->cbb;
    D.44250->last_ins = inst;
    D.44251 = D.44250->last_ins;
    D.44250->code = D.44251;
    <D.44254>:
  }
  mini_emit_max_iid_check (cfg, max_iid_reg, klass, false_target);
}


mini_emit_max_iid_check (struct MonoCompile * cfg, int max_iid_reg, struct MonoClass * klass, struct MonoBasicBlock * false_target)
{
  long unsigned int D.44255;
  long unsigned int D.44256;
  unsigned int D.44259;
  struct MonoMemPool * D.44260;
  long int D.44261;
  struct MonoInst * D.44262;
  guint16 iftmp.374;
  int D.44267;
  int D.44268;
  const unsigned char * D.44269;
  struct MonoBasicBlock * D.44270;
  struct MonoInst * D.44271;
  long int D.44275;
  struct MonoInst * D.44276;
  int D.44277;
  int D.44278;
  long int D.44283;
  struct MonoInst * D.44284;
  int D.44285;
  int D.44286;
  short unsigned int D.44287;
  long int D.44288;
  long int D.44294;
  struct MonoInst * D.44295;
  int D.44296;
  int D.44297;
  unsigned int D.44300;
  unsigned int D.44301;
  unsigned int D.44302;
  int D.44303;
  unsigned char * D.44307;
  struct MonoBasicBlock * * D.44310;
  long int D.44311;
  unsigned char * D.44312;
  long int D.44313;
  long int D.44314;
  long unsigned int D.44315;
  long unsigned int D.44316;
  struct MonoBasicBlock * * D.44317;
  unsigned int D.44318;
  short unsigned int D.44323;
  short unsigned int D.44324;
  short unsigned int D.44326;
  short unsigned int D.44328;
  struct MonoBasicBlock * * D.44329;
  struct MonoBasicBlock * * D.44330;
  struct MonoBasicBlock * D.44331;
  void * D.44341;
  struct MonoBasicBlock * * D.44342;
  struct MonoBasicBlock * * D.44343;
  long unsigned int D.44347;
  unsigned int D.44350;
  unsigned int D.44351;
  int D.44352;
  long int D.44371;
  struct MonoInst * D.44372;
  int D.44373;
  int D.44374;

  D.44255 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.44256 = D.44255 & 33554432;
  if (D.44256 != 0) goto <D.44257>; else goto <D.44258>;
  <D.44257>:
  {
    int iid_reg;

    D.44259 = alloc_preg (cfg);
    iid_reg = (int) D.44259;
    {
      struct MonoInst * inst;

      D.44260 = cfg->mempool;
      inst = mono_mempool_alloc (D.44260, 80);
      inst->data.op[1].const_val = 0;
      D.44261 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.44261;
      inst->prev = 0B;
      D.44262 = inst->prev;
      inst->next = D.44262;
      D.44255 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.44256 = D.44255 & 33554432;
      if (D.44256 != 0) goto <D.44264>; else goto <D.44265>;
      <D.44264>:
      iftmp.374 = 732;
      goto <D.44266>;
      <D.44265>:
      iftmp.374 = 363;
      <D.44266>:
      inst->opcode = iftmp.374;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.44267 = inst->sreg3;
      inst->sreg2 = D.44267;
      D.44268 = inst->sreg2;
      inst->sreg1 = D.44268;
      D.44269 = cfg->ip;
      inst->cil_code = D.44269;
      inst->dreg = iid_reg;
      inst->data.op[0].p = klass;
      inst->data.op[1].const_val = 23;
      D.44270 = cfg->cbb;
      D.44271 = D.44270->last_ins;
      if (D.44271 != 0B) goto <D.44272>; else goto <D.44273>;
      <D.44272>:
      D.44270 = cfg->cbb;
      D.44271 = D.44270->last_ins;
      D.44271->next = inst;
      D.44270 = cfg->cbb;
      D.44271 = D.44270->last_ins;
      inst->prev = D.44271;
      D.44270 = cfg->cbb;
      D.44270->last_ins = inst;
      goto <D.44274>;
      <D.44273>:
      D.44270 = cfg->cbb;
      D.44270 = cfg->cbb;
      D.44270->last_ins = inst;
      D.44271 = D.44270->last_ins;
      D.44270->code = D.44271;
      <D.44274>:
    }
    {
      struct MonoInst * inst;

      D.44260 = cfg->mempool;
      inst = mono_mempool_alloc (D.44260, 80);
      inst->data.op[1].const_val = 0;
      D.44275 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.44275;
      inst->prev = 0B;
      D.44276 = inst->prev;
      inst->next = D.44276;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.44277 = inst->sreg3;
      inst->sreg2 = D.44277;
      D.44278 = inst->sreg2;
      inst->sreg1 = D.44278;
      D.44269 = cfg->ip;
      inst->cil_code = D.44269;
      inst->dreg = -1;
      inst->sreg1 = max_iid_reg;
      inst->sreg2 = iid_reg;
      D.44270 = cfg->cbb;
      D.44271 = D.44270->last_ins;
      if (D.44271 != 0B) goto <D.44279>; else goto <D.44280>;
      <D.44279>:
      D.44270 = cfg->cbb;
      D.44271 = D.44270->last_ins;
      D.44271->next = inst;
      D.44270 = cfg->cbb;
      D.44271 = D.44270->last_ins;
      inst->prev = D.44271;
      D.44270 = cfg->cbb;
      D.44270->last_ins = inst;
      goto <D.44281>;
      <D.44280>:
      D.44270 = cfg->cbb;
      D.44270 = cfg->cbb;
      D.44270->last_ins = inst;
      D.44271 = D.44270->last_ins;
      D.44270->code = D.44271;
      <D.44281>:
    }
  }
  goto <D.44282>;
  <D.44258>:
  {
    struct MonoInst * inst;

    D.44260 = cfg->mempool;
    inst = mono_mempool_alloc (D.44260, 80);
    inst->data.op[1].const_val = 0;
    D.44283 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44283;
    inst->prev = 0B;
    D.44284 = inst->prev;
    inst->next = D.44284;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44285 = inst->sreg3;
    inst->sreg2 = D.44285;
    D.44286 = inst->sreg2;
    inst->sreg1 = D.44286;
    D.44269 = cfg->ip;
    inst->cil_code = D.44269;
    inst->dreg = -1;
    inst->sreg1 = max_iid_reg;
    D.44287 = klass->interface_id;
    D.44288 = (long int) D.44287;
    inst->data.op[1].const_val = D.44288;
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    if (D.44271 != 0B) goto <D.44289>; else goto <D.44290>;
    <D.44289>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44271->next = inst;
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    inst->prev = D.44271;
    D.44270 = cfg->cbb;
    D.44270->last_ins = inst;
    goto <D.44291>;
    <D.44290>:
    D.44270 = cfg->cbb;
    D.44270 = cfg->cbb;
    D.44270->last_ins = inst;
    D.44271 = D.44270->last_ins;
    D.44270->code = D.44271;
    <D.44291>:
  }
  <D.44282>:
  if (false_target != 0B) goto <D.44292>; else goto <D.44293>;
  <D.44292>:
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.44260 = cfg->mempool;
    ins = mono_mempool_alloc (D.44260, 80);
    ins->data.op[1].const_val = 0;
    D.44294 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.44294;
    ins->prev = 0B;
    D.44295 = ins->prev;
    ins->next = D.44295;
    ins->opcode = 560;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.44296 = ins->sreg3;
    ins->sreg2 = D.44296;
    D.44297 = ins->sreg2;
    ins->sreg1 = D.44297;
    D.44269 = cfg->ip;
    ins->cil_code = D.44269;
    if (0 != 0) goto <D.44298>; else goto <D.44299>;
    <D.44298>:
    D.44260 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.44260, 296);
    D.44300 = cfg->num_bblocks;
    D.44301 = D.44300;
    D.44302 = D.44301 + 1;
    cfg->num_bblocks = D.44302;
    D.44303 = (int) D.44301;
    falsebb->block_num = D.44303;
    ins->data.op[0].target_block = false_target;
    D.44270 = cfg->cbb;
    mono_link_bblock (cfg, D.44270, false_target);
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    if (D.44271 != 0B) goto <D.44304>; else goto <D.44305>;
    <D.44304>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44271->next = ins;
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    ins->prev = D.44271;
    D.44270 = cfg->cbb;
    D.44270->last_ins = ins;
    goto <D.44306>;
    <D.44305>:
    D.44270 = cfg->cbb;
    D.44270 = cfg->cbb;
    D.44270->last_ins = ins;
    D.44271 = D.44270->last_ins;
    D.44270->code = D.44271;
    <D.44306>:
    D.44307 = falsebb->cil_code;
    if (D.44307 != 0B) goto <D.44308>; else goto <D.44309>;
    <D.44308>:
    D.44310 = cfg->cil_offset_to_bb;
    D.44307 = falsebb->cil_code;
    D.44311 = (long int) D.44307;
    D.44312 = cfg->cil_start;
    D.44313 = (long int) D.44312;
    D.44314 = D.44311 - D.44313;
    D.44315 = (long unsigned int) D.44314;
    D.44316 = D.44315 * 8;
    D.44317 = D.44310 + D.44316;
    *D.44317 = falsebb;
    <D.44309>:
    D.44318 = cfg->real_offset;
    falsebb->real_offset = D.44318;
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    if (D.44271 != 0B) goto <D.44322>; else goto <D.44319>;
    <D.44322>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44323 = D.44271->opcode;
    D.44324 = D.44323 + 64985;
    if (D.44324 <= 9) goto <D.44320>; else goto <D.44325>;
    <D.44325>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44323 = D.44271->opcode;
    D.44326 = D.44323 + 64878;
    if (D.44326 <= 9) goto <D.44320>; else goto <D.44327>;
    <D.44327>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44323 = D.44271->opcode;
    D.44328 = D.44323 + 64888;
    if (D.44328 <= 9) goto <D.44320>; else goto <D.44319>;
    <D.44320>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44329 = D.44271->data.op[1].many_blocks;
    D.44330 = D.44329 + 8;
    D.44331 = *D.44330;
    if (D.44331 == 0B) goto <D.44332>; else goto <D.44319>;
    <D.44332>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44329 = D.44271->data.op[1].many_blocks;
    D.44330 = D.44329 + 8;
    *D.44330 = falsebb;
    D.44270 = cfg->cbb;
    mono_link_bblock (cfg, D.44270, falsebb);
    goto <D.44321>;
    <D.44319>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    if (D.44271 == 0B) goto <D.44333>; else goto <D.44335>;
    <D.44335>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44323 = D.44271->opcode;
    if (D.44323 != 442) goto <D.44336>; else goto <D.44334>;
    <D.44336>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44323 = D.44271->opcode;
    if (D.44323 != 759) goto <D.44337>; else goto <D.44334>;
    <D.44337>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44323 = D.44271->opcode;
    D.44324 = D.44323 + 64985;
    if (D.44324 > 9) goto <D.44338>; else goto <D.44334>;
    <D.44338>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44323 = D.44271->opcode;
    D.44326 = D.44323 + 64878;
    if (D.44326 > 9) goto <D.44339>; else goto <D.44334>;
    <D.44339>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44323 = D.44271->opcode;
    D.44328 = D.44323 + 64888;
    if (D.44328 > 9) goto <D.44333>; else goto <D.44334>;
    <D.44333>:
    D.44270 = cfg->cbb;
    mono_link_bblock (cfg, D.44270, falsebb);
    <D.44334>:
    <D.44321>:
    D.44270 = cfg->cbb;
    D.44270->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.44340>;
    <D.44299>:
    D.44260 = cfg->mempool;
    D.44341 = mono_mempool_alloc (D.44260, 16);
    ins->data.op[1].many_blocks = D.44341;
    D.44342 = ins->data.op[1].many_blocks;
    *D.44342 = false_target;
    D.44342 = ins->data.op[1].many_blocks;
    D.44343 = D.44342 + 8;
    *D.44343 = 0B;
    D.44270 = cfg->cbb;
    mono_link_bblock (cfg, D.44270, false_target);
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    if (D.44271 != 0B) goto <D.44344>; else goto <D.44345>;
    <D.44344>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44271->next = ins;
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    ins->prev = D.44271;
    D.44270 = cfg->cbb;
    D.44270->last_ins = ins;
    goto <D.44346>;
    <D.44345>:
    D.44270 = cfg->cbb;
    D.44270 = cfg->cbb;
    D.44270->last_ins = ins;
    D.44271 = D.44270->last_ins;
    D.44270->code = D.44271;
    <D.44346>:
    D.44255 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.44347 = D.44255 & 268435456;
    if (D.44347 == 0) goto <D.44348>; else goto <D.44349>;
    <D.44348>:
    D.44260 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.44260, 296);
    D.44300 = cfg->num_bblocks;
    D.44350 = D.44300;
    D.44351 = D.44350 + 1;
    cfg->num_bblocks = D.44351;
    D.44352 = (int) D.44350;
    falsebb->block_num = D.44352;
    D.44342 = ins->data.op[1].many_blocks;
    D.44343 = D.44342 + 8;
    *D.44343 = falsebb;
    D.44270 = cfg->cbb;
    mono_link_bblock (cfg, D.44270, falsebb);
    D.44307 = falsebb->cil_code;
    if (D.44307 != 0B) goto <D.44353>; else goto <D.44354>;
    <D.44353>:
    D.44310 = cfg->cil_offset_to_bb;
    D.44307 = falsebb->cil_code;
    D.44311 = (long int) D.44307;
    D.44312 = cfg->cil_start;
    D.44313 = (long int) D.44312;
    D.44314 = D.44311 - D.44313;
    D.44315 = (long unsigned int) D.44314;
    D.44316 = D.44315 * 8;
    D.44317 = D.44310 + D.44316;
    *D.44317 = falsebb;
    <D.44354>:
    D.44318 = cfg->real_offset;
    falsebb->real_offset = D.44318;
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    if (D.44271 != 0B) goto <D.44358>; else goto <D.44355>;
    <D.44358>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44323 = D.44271->opcode;
    D.44324 = D.44323 + 64985;
    if (D.44324 <= 9) goto <D.44356>; else goto <D.44359>;
    <D.44359>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44323 = D.44271->opcode;
    D.44326 = D.44323 + 64878;
    if (D.44326 <= 9) goto <D.44356>; else goto <D.44360>;
    <D.44360>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44323 = D.44271->opcode;
    D.44328 = D.44323 + 64888;
    if (D.44328 <= 9) goto <D.44356>; else goto <D.44355>;
    <D.44356>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44329 = D.44271->data.op[1].many_blocks;
    D.44330 = D.44329 + 8;
    D.44331 = *D.44330;
    if (D.44331 == 0B) goto <D.44361>; else goto <D.44355>;
    <D.44361>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44329 = D.44271->data.op[1].many_blocks;
    D.44330 = D.44329 + 8;
    *D.44330 = falsebb;
    D.44270 = cfg->cbb;
    mono_link_bblock (cfg, D.44270, falsebb);
    goto <D.44357>;
    <D.44355>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    if (D.44271 == 0B) goto <D.44362>; else goto <D.44364>;
    <D.44364>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44323 = D.44271->opcode;
    if (D.44323 != 442) goto <D.44365>; else goto <D.44363>;
    <D.44365>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44323 = D.44271->opcode;
    if (D.44323 != 759) goto <D.44366>; else goto <D.44363>;
    <D.44366>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44323 = D.44271->opcode;
    D.44324 = D.44323 + 64985;
    if (D.44324 > 9) goto <D.44367>; else goto <D.44363>;
    <D.44367>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44323 = D.44271->opcode;
    D.44326 = D.44323 + 64878;
    if (D.44326 > 9) goto <D.44368>; else goto <D.44363>;
    <D.44368>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44323 = D.44271->opcode;
    D.44328 = D.44323 + 64888;
    if (D.44328 > 9) goto <D.44362>; else goto <D.44363>;
    <D.44362>:
    D.44270 = cfg->cbb;
    mono_link_bblock (cfg, D.44270, falsebb);
    <D.44363>:
    <D.44357>:
    D.44270 = cfg->cbb;
    D.44270->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.44369>;
    <D.44349>:
    D.44270 = cfg->cbb;
    D.44270->extended = 1;
    <D.44369>:
    <D.44340>:
  }
  goto <D.44370>;
  <D.44293>:
  {
    struct MonoInst * inst;

    D.44260 = cfg->mempool;
    inst = mono_mempool_alloc (D.44260, 80);
    inst->data.op[1].const_val = 0;
    D.44371 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44371;
    inst->prev = 0B;
    D.44372 = inst->prev;
    inst->next = D.44372;
    inst->opcode = 460;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44373 = inst->sreg3;
    inst->sreg2 = D.44373;
    D.44374 = inst->sreg2;
    inst->sreg1 = D.44374;
    D.44269 = cfg->ip;
    inst->cil_code = D.44269;
    inst->data.op[1].p = "InvalidCastException";
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    if (D.44271 != 0B) goto <D.44375>; else goto <D.44376>;
    <D.44375>:
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    D.44271->next = inst;
    D.44270 = cfg->cbb;
    D.44271 = D.44270->last_ins;
    inst->prev = D.44271;
    D.44270 = cfg->cbb;
    D.44270->last_ins = inst;
    goto <D.44377>;
    <D.44376>:
    D.44270 = cfg->cbb;
    D.44270 = cfg->cbb;
    D.44270->last_ins = inst;
    D.44271 = D.44270->last_ins;
    D.44270->code = D.44271;
    <D.44377>:
  }
  <D.44370>:
}


mini_emit_load_intf_bit_reg_vtable (struct MonoCompile * cfg, int intf_bit_reg, int vtable_reg, struct MonoClass * klass)
{
  mini_emit_interface_bitmap_check (cfg, intf_bit_reg, vtable_reg, 32, klass);
}


mini_emit_interface_bitmap_check (struct MonoCompile * cfg, int intf_bit_reg, int base_reg, int offset, struct MonoClass * klass)
{
  unsigned int D.44378;
  unsigned int D.44379;
  struct MonoMemPool * D.44380;
  long int D.44381;
  struct MonoInst * D.44382;
  int D.44383;
  int D.44384;
  const unsigned char * D.44385;
  long int D.44386;
  struct MonoBasicBlock * D.44387;
  struct MonoInst * D.44388;
  long unsigned int D.44392;
  long unsigned int D.44393;
  unsigned int D.44396;
  unsigned int D.44397;
  unsigned int D.44398;
  unsigned int D.44399;
  unsigned int D.44400;
  unsigned int D.44401;
  long int D.44402;
  struct MonoInst * D.44403;
  guint16 iftmp.375;
  int D.44408;
  int D.44409;
  long int D.44413;
  struct MonoInst * D.44414;
  int D.44415;
  int D.44416;
  long int D.44420;
  struct MonoInst * D.44421;
  int D.44422;
  int D.44423;
  long int D.44427;
  struct MonoInst * D.44428;
  int D.44429;
  int D.44430;
  long int D.44434;
  struct MonoInst * D.44435;
  int D.44436;
  int D.44437;
  long int D.44441;
  struct MonoInst * D.44442;
  int D.44443;
  int D.44444;
  long int D.44448;
  struct MonoInst * D.44449;
  int D.44450;
  int D.44451;
  long int D.44455;
  struct MonoInst * D.44456;
  int D.44457;
  int D.44458;
  long int D.44463;
  struct MonoInst * D.44464;
  int D.44465;
  int D.44466;
  short unsigned int D.44467;
  short unsigned int D.44468;
  long int D.44469;
  long int D.44473;
  struct MonoInst * D.44474;
  int D.44475;
  int D.44476;
  int D.44477;
  int D.44478;
  int D.44479;
  long int D.44480;
  int ibitmap_reg;
  int ibitmap_byte_reg;

  D.44378 = alloc_preg (cfg);
  ibitmap_reg = (int) D.44378;
  D.44379 = alloc_preg (cfg);
  ibitmap_byte_reg = (int) D.44379;
  {
    struct MonoInst * inst;

    D.44380 = cfg->mempool;
    inst = mono_mempool_alloc (D.44380, 80);
    inst->data.op[1].const_val = 0;
    D.44381 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44381;
    inst->prev = 0B;
    D.44382 = inst->prev;
    inst->next = D.44382;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44383 = inst->sreg3;
    inst->sreg2 = D.44383;
    D.44384 = inst->sreg2;
    inst->sreg1 = D.44384;
    D.44385 = cfg->ip;
    inst->cil_code = D.44385;
    inst->dreg = ibitmap_reg;
    inst->sreg1 = base_reg;
    D.44386 = (long int) offset;
    inst->data.op[0].const_val = D.44386;
    D.44387 = cfg->cbb;
    D.44388 = D.44387->last_ins;
    if (D.44388 != 0B) goto <D.44389>; else goto <D.44390>;
    <D.44389>:
    D.44387 = cfg->cbb;
    D.44388 = D.44387->last_ins;
    D.44388->next = inst;
    D.44387 = cfg->cbb;
    D.44388 = D.44387->last_ins;
    inst->prev = D.44388;
    D.44387 = cfg->cbb;
    D.44387->last_ins = inst;
    goto <D.44391>;
    <D.44390>:
    D.44387 = cfg->cbb;
    D.44387 = cfg->cbb;
    D.44387->last_ins = inst;
    D.44388 = D.44387->last_ins;
    D.44387->code = D.44388;
    <D.44391>:
  }
  D.44392 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.44393 = D.44392 & 33554432;
  if (D.44393 != 0) goto <D.44394>; else goto <D.44395>;
  <D.44394>:
  {
    int iid_reg;
    int shifted_iid_reg;
    int ibitmap_byte_address_reg;
    int masked_iid_reg;
    int iid_one_bit_reg;
    int iid_bit_reg;

    D.44396 = alloc_preg (cfg);
    iid_reg = (int) D.44396;
    D.44397 = alloc_preg (cfg);
    shifted_iid_reg = (int) D.44397;
    D.44398 = alloc_preg (cfg);
    ibitmap_byte_address_reg = (int) D.44398;
    D.44399 = alloc_preg (cfg);
    masked_iid_reg = (int) D.44399;
    D.44400 = alloc_preg (cfg);
    iid_one_bit_reg = (int) D.44400;
    D.44401 = alloc_preg (cfg);
    iid_bit_reg = (int) D.44401;
    {
      struct MonoInst * inst;

      D.44380 = cfg->mempool;
      inst = mono_mempool_alloc (D.44380, 80);
      inst->data.op[1].const_val = 0;
      D.44402 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.44402;
      inst->prev = 0B;
      D.44403 = inst->prev;
      inst->next = D.44403;
      D.44392 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.44393 = D.44392 & 33554432;
      if (D.44393 != 0) goto <D.44405>; else goto <D.44406>;
      <D.44405>:
      iftmp.375 = 732;
      goto <D.44407>;
      <D.44406>:
      iftmp.375 = 363;
      <D.44407>:
      inst->opcode = iftmp.375;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.44408 = inst->sreg3;
      inst->sreg2 = D.44408;
      D.44409 = inst->sreg2;
      inst->sreg1 = D.44409;
      D.44385 = cfg->ip;
      inst->cil_code = D.44385;
      inst->dreg = iid_reg;
      inst->data.op[0].p = klass;
      inst->data.op[1].const_val = 23;
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      if (D.44388 != 0B) goto <D.44410>; else goto <D.44411>;
      <D.44410>:
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      D.44388->next = inst;
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      inst->prev = D.44388;
      D.44387 = cfg->cbb;
      D.44387->last_ins = inst;
      goto <D.44412>;
      <D.44411>:
      D.44387 = cfg->cbb;
      D.44387 = cfg->cbb;
      D.44387->last_ins = inst;
      D.44388 = D.44387->last_ins;
      D.44387->code = D.44388;
      <D.44412>:
    }
    {
      struct MonoInst * inst;

      D.44380 = cfg->mempool;
      inst = mono_mempool_alloc (D.44380, 80);
      inst->data.op[1].const_val = 0;
      D.44413 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.44413;
      inst->prev = 0B;
      D.44414 = inst->prev;
      inst->next = D.44414;
      inst->opcode = 440;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.44415 = inst->sreg3;
      inst->sreg2 = D.44415;
      D.44416 = inst->sreg2;
      inst->sreg1 = D.44416;
      D.44385 = cfg->ip;
      inst->cil_code = D.44385;
      inst->dreg = shifted_iid_reg;
      inst->sreg1 = iid_reg;
      inst->data.op[1].const_val = 3;
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      if (D.44388 != 0B) goto <D.44417>; else goto <D.44418>;
      <D.44417>:
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      D.44388->next = inst;
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      inst->prev = D.44388;
      D.44387 = cfg->cbb;
      D.44387->last_ins = inst;
      goto <D.44419>;
      <D.44418>:
      D.44387 = cfg->cbb;
      D.44387 = cfg->cbb;
      D.44387->last_ins = inst;
      D.44388 = D.44387->last_ins;
      D.44387->code = D.44388;
      <D.44419>:
    }
    {
      struct MonoInst * inst;

      D.44380 = cfg->mempool;
      inst = mono_mempool_alloc (D.44380, 80);
      inst->data.op[1].const_val = 0;
      D.44420 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.44420;
      inst->prev = 0B;
      D.44421 = inst->prev;
      inst->next = D.44421;
      inst->opcode = 479;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.44422 = inst->sreg3;
      inst->sreg2 = D.44422;
      D.44423 = inst->sreg2;
      inst->sreg1 = D.44423;
      D.44385 = cfg->ip;
      inst->cil_code = D.44385;
      inst->dreg = ibitmap_byte_address_reg;
      inst->sreg1 = ibitmap_reg;
      inst->sreg2 = shifted_iid_reg;
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      if (D.44388 != 0B) goto <D.44424>; else goto <D.44425>;
      <D.44424>:
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      D.44388->next = inst;
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      inst->prev = D.44388;
      D.44387 = cfg->cbb;
      D.44387->last_ins = inst;
      goto <D.44426>;
      <D.44425>:
      D.44387 = cfg->cbb;
      D.44387 = cfg->cbb;
      D.44387->last_ins = inst;
      D.44388 = D.44387->last_ins;
      D.44387->code = D.44388;
      <D.44426>:
    }
    {
      struct MonoInst * inst;

      D.44380 = cfg->mempool;
      inst = mono_mempool_alloc (D.44380, 80);
      inst->data.op[1].const_val = 0;
      D.44427 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.44427;
      inst->prev = 0B;
      D.44428 = inst->prev;
      inst->next = D.44428;
      inst->opcode = 390;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.44429 = inst->sreg3;
      inst->sreg2 = D.44429;
      D.44430 = inst->sreg2;
      inst->sreg1 = D.44430;
      D.44385 = cfg->ip;
      inst->cil_code = D.44385;
      inst->dreg = ibitmap_byte_reg;
      inst->sreg1 = ibitmap_byte_address_reg;
      inst->data.op[0].const_val = 0;
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      if (D.44388 != 0B) goto <D.44431>; else goto <D.44432>;
      <D.44431>:
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      D.44388->next = inst;
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      inst->prev = D.44388;
      D.44387 = cfg->cbb;
      D.44387->last_ins = inst;
      goto <D.44433>;
      <D.44432>:
      D.44387 = cfg->cbb;
      D.44387 = cfg->cbb;
      D.44387->last_ins = inst;
      D.44388 = D.44387->last_ins;
      D.44387->code = D.44388;
      <D.44433>:
    }
    {
      struct MonoInst * inst;

      D.44380 = cfg->mempool;
      inst = mono_mempool_alloc (D.44380, 80);
      inst->data.op[1].const_val = 0;
      D.44434 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.44434;
      inst->prev = 0B;
      D.44435 = inst->prev;
      inst->next = D.44435;
      inst->opcode = 632;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.44436 = inst->sreg3;
      inst->sreg2 = D.44436;
      D.44437 = inst->sreg2;
      inst->sreg1 = D.44437;
      D.44385 = cfg->ip;
      inst->cil_code = D.44385;
      inst->dreg = masked_iid_reg;
      inst->sreg1 = iid_reg;
      inst->data.op[1].const_val = 7;
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      if (D.44388 != 0B) goto <D.44438>; else goto <D.44439>;
      <D.44438>:
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      D.44388->next = inst;
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      inst->prev = D.44388;
      D.44387 = cfg->cbb;
      D.44387->last_ins = inst;
      goto <D.44440>;
      <D.44439>:
      D.44387 = cfg->cbb;
      D.44387 = cfg->cbb;
      D.44387->last_ins = inst;
      D.44388 = D.44387->last_ins;
      D.44387->code = D.44388;
      <D.44440>:
    }
    {
      struct MonoInst * inst;

      D.44380 = cfg->mempool;
      inst = mono_mempool_alloc (D.44380, 80);
      inst->data.op[1].const_val = 0;
      D.44441 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.44441;
      inst->prev = 0B;
      D.44442 = inst->prev;
      inst->next = D.44442;
      inst->opcode = 362;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.44443 = inst->sreg3;
      inst->sreg2 = D.44443;
      D.44444 = inst->sreg2;
      inst->sreg1 = D.44444;
      D.44385 = cfg->ip;
      inst->cil_code = D.44385;
      inst->dreg = iid_one_bit_reg;
      inst->data.op[0].const_val = 1;
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      if (D.44388 != 0B) goto <D.44445>; else goto <D.44446>;
      <D.44445>:
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      D.44388->next = inst;
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      inst->prev = D.44388;
      D.44387 = cfg->cbb;
      D.44387->last_ins = inst;
      goto <D.44447>;
      <D.44446>:
      D.44387 = cfg->cbb;
      D.44387 = cfg->cbb;
      D.44387->last_ins = inst;
      D.44388 = D.44387->last_ins;
      D.44387->code = D.44388;
      <D.44447>:
    }
    {
      struct MonoInst * inst;

      D.44380 = cfg->mempool;
      inst = mono_mempool_alloc (D.44380, 80);
      inst->data.op[1].const_val = 0;
      D.44448 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.44448;
      inst->prev = 0B;
      D.44449 = inst->prev;
      inst->next = D.44449;
      inst->opcode = 575;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.44450 = inst->sreg3;
      inst->sreg2 = D.44450;
      D.44451 = inst->sreg2;
      inst->sreg1 = D.44451;
      D.44385 = cfg->ip;
      inst->cil_code = D.44385;
      inst->dreg = iid_bit_reg;
      inst->sreg1 = iid_one_bit_reg;
      inst->sreg2 = masked_iid_reg;
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      if (D.44388 != 0B) goto <D.44452>; else goto <D.44453>;
      <D.44452>:
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      D.44388->next = inst;
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      inst->prev = D.44388;
      D.44387 = cfg->cbb;
      D.44387->last_ins = inst;
      goto <D.44454>;
      <D.44453>:
      D.44387 = cfg->cbb;
      D.44387 = cfg->cbb;
      D.44387->last_ins = inst;
      D.44388 = D.44387->last_ins;
      D.44387->code = D.44388;
      <D.44454>:
    }
    {
      struct MonoInst * inst;

      D.44380 = cfg->mempool;
      inst = mono_mempool_alloc (D.44380, 80);
      inst->data.op[1].const_val = 0;
      D.44455 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.44455;
      inst->prev = 0B;
      D.44456 = inst->prev;
      inst->next = D.44456;
      inst->opcode = 572;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.44457 = inst->sreg3;
      inst->sreg2 = D.44457;
      D.44458 = inst->sreg2;
      inst->sreg1 = D.44458;
      D.44385 = cfg->ip;
      inst->cil_code = D.44385;
      inst->dreg = intf_bit_reg;
      inst->sreg1 = ibitmap_byte_reg;
      inst->sreg2 = iid_bit_reg;
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      if (D.44388 != 0B) goto <D.44459>; else goto <D.44460>;
      <D.44459>:
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      D.44388->next = inst;
      D.44387 = cfg->cbb;
      D.44388 = D.44387->last_ins;
      inst->prev = D.44388;
      D.44387 = cfg->cbb;
      D.44387->last_ins = inst;
      goto <D.44461>;
      <D.44460>:
      D.44387 = cfg->cbb;
      D.44387 = cfg->cbb;
      D.44387->last_ins = inst;
      D.44388 = D.44387->last_ins;
      D.44387->code = D.44388;
      <D.44461>:
    }
  }
  goto <D.44462>;
  <D.44395>:
  {
    struct MonoInst * inst;

    D.44380 = cfg->mempool;
    inst = mono_mempool_alloc (D.44380, 80);
    inst->data.op[1].const_val = 0;
    D.44463 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44463;
    inst->prev = 0B;
    D.44464 = inst->prev;
    inst->next = D.44464;
    inst->opcode = 389;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44465 = inst->sreg3;
    inst->sreg2 = D.44465;
    D.44466 = inst->sreg2;
    inst->sreg1 = D.44466;
    D.44385 = cfg->ip;
    inst->cil_code = D.44385;
    inst->dreg = ibitmap_byte_reg;
    inst->sreg1 = ibitmap_reg;
    D.44467 = klass->interface_id;
    D.44468 = D.44467 >> 3;
    D.44469 = (long int) D.44468;
    inst->data.op[0].const_val = D.44469;
    D.44387 = cfg->cbb;
    D.44388 = D.44387->last_ins;
    if (D.44388 != 0B) goto <D.44470>; else goto <D.44471>;
    <D.44470>:
    D.44387 = cfg->cbb;
    D.44388 = D.44387->last_ins;
    D.44388->next = inst;
    D.44387 = cfg->cbb;
    D.44388 = D.44387->last_ins;
    inst->prev = D.44388;
    D.44387 = cfg->cbb;
    D.44387->last_ins = inst;
    goto <D.44472>;
    <D.44471>:
    D.44387 = cfg->cbb;
    D.44387 = cfg->cbb;
    D.44387->last_ins = inst;
    D.44388 = D.44387->last_ins;
    D.44387->code = D.44388;
    <D.44472>:
  }
  {
    struct MonoInst * inst;

    D.44380 = cfg->mempool;
    inst = mono_mempool_alloc (D.44380, 80);
    inst->data.op[1].const_val = 0;
    D.44473 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44473;
    inst->prev = 0B;
    D.44474 = inst->prev;
    inst->next = D.44474;
    inst->opcode = 436;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44475 = inst->sreg3;
    inst->sreg2 = D.44475;
    D.44476 = inst->sreg2;
    inst->sreg1 = D.44476;
    D.44385 = cfg->ip;
    inst->cil_code = D.44385;
    inst->dreg = intf_bit_reg;
    inst->sreg1 = ibitmap_byte_reg;
    D.44467 = klass->interface_id;
    D.44477 = (int) D.44467;
    D.44478 = D.44477 & 7;
    D.44479 = 1 << D.44478;
    D.44480 = (long int) D.44479;
    inst->data.op[1].const_val = D.44480;
    D.44387 = cfg->cbb;
    D.44388 = D.44387->last_ins;
    if (D.44388 != 0B) goto <D.44481>; else goto <D.44482>;
    <D.44481>:
    D.44387 = cfg->cbb;
    D.44388 = D.44387->last_ins;
    D.44388->next = inst;
    D.44387 = cfg->cbb;
    D.44388 = D.44387->last_ins;
    inst->prev = D.44388;
    D.44387 = cfg->cbb;
    D.44387->last_ins = inst;
    goto <D.44483>;
    <D.44482>:
    D.44387 = cfg->cbb;
    D.44387 = cfg->cbb;
    D.44387->last_ins = inst;
    D.44388 = D.44387->last_ins;
    D.44387->code = D.44388;
    <D.44483>:
  }
  <D.44462>:
}


mini_emit_class_check_branch (struct MonoCompile * cfg, int klass_reg, struct MonoClass * klass, int branch_op, struct MonoBasicBlock * target)
{
  long unsigned int D.44484;
  long unsigned int D.44485;
  unsigned int D.44488;
  struct MonoMemPool * D.44489;
  long int D.44490;
  struct MonoInst * D.44491;
  guint16 iftmp.376;
  int D.44496;
  int D.44497;
  const unsigned char * D.44498;
  struct MonoBasicBlock * D.44499;
  struct MonoInst * D.44500;
  long int D.44504;
  struct MonoInst * D.44505;
  int D.44506;
  int D.44507;
  long int D.44512;
  struct MonoInst * D.44513;
  int D.44514;
  int D.44515;
  long int klass.377;
  long int D.44520;
  struct MonoInst * D.44521;
  short unsigned int D.44522;
  int D.44523;
  int D.44524;
  unsigned int D.44527;
  unsigned int D.44528;
  unsigned int D.44529;
  int D.44530;
  unsigned char * D.44534;
  struct MonoBasicBlock * * D.44537;
  long int D.44538;
  unsigned char * D.44539;
  long int D.44540;
  long int D.44541;
  long unsigned int D.44542;
  long unsigned int D.44543;
  struct MonoBasicBlock * * D.44544;
  unsigned int D.44545;
  short unsigned int D.44550;
  short unsigned int D.44551;
  short unsigned int D.44553;
  short unsigned int D.44555;
  struct MonoBasicBlock * * D.44556;
  struct MonoBasicBlock * * D.44557;
  struct MonoBasicBlock * D.44558;
  void * D.44568;
  struct MonoBasicBlock * * D.44569;
  struct MonoBasicBlock * * D.44570;
  long unsigned int D.44574;
  unsigned int D.44577;
  unsigned int D.44578;
  int D.44579;

  D.44484 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.44485 = D.44484 & 33554432;
  if (D.44485 != 0) goto <D.44486>; else goto <D.44487>;
  <D.44486>:
  {
    int const_reg;

    D.44488 = alloc_preg (cfg);
    const_reg = (int) D.44488;
    {
      struct MonoInst * inst;

      D.44489 = cfg->mempool;
      inst = mono_mempool_alloc (D.44489, 80);
      inst->data.op[1].const_val = 0;
      D.44490 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.44490;
      inst->prev = 0B;
      D.44491 = inst->prev;
      inst->next = D.44491;
      D.44484 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.44485 = D.44484 & 33554432;
      if (D.44485 != 0) goto <D.44493>; else goto <D.44494>;
      <D.44493>:
      iftmp.376 = 732;
      goto <D.44495>;
      <D.44494>:
      iftmp.376 = 363;
      <D.44495>:
      inst->opcode = iftmp.376;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.44496 = inst->sreg3;
      inst->sreg2 = D.44496;
      D.44497 = inst->sreg2;
      inst->sreg1 = D.44497;
      D.44498 = cfg->ip;
      inst->cil_code = D.44498;
      inst->dreg = const_reg;
      inst->data.op[0].p = klass;
      inst->data.op[1].const_val = 11;
      D.44499 = cfg->cbb;
      D.44500 = D.44499->last_ins;
      if (D.44500 != 0B) goto <D.44501>; else goto <D.44502>;
      <D.44501>:
      D.44499 = cfg->cbb;
      D.44500 = D.44499->last_ins;
      D.44500->next = inst;
      D.44499 = cfg->cbb;
      D.44500 = D.44499->last_ins;
      inst->prev = D.44500;
      D.44499 = cfg->cbb;
      D.44499->last_ins = inst;
      goto <D.44503>;
      <D.44502>:
      D.44499 = cfg->cbb;
      D.44499 = cfg->cbb;
      D.44499->last_ins = inst;
      D.44500 = D.44499->last_ins;
      D.44499->code = D.44500;
      <D.44503>:
    }
    {
      struct MonoInst * inst;

      D.44489 = cfg->mempool;
      inst = mono_mempool_alloc (D.44489, 80);
      inst->data.op[1].const_val = 0;
      D.44504 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.44504;
      inst->prev = 0B;
      D.44505 = inst->prev;
      inst->next = D.44505;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.44506 = inst->sreg3;
      inst->sreg2 = D.44506;
      D.44507 = inst->sreg2;
      inst->sreg1 = D.44507;
      D.44498 = cfg->ip;
      inst->cil_code = D.44498;
      inst->dreg = -1;
      inst->sreg1 = klass_reg;
      inst->sreg2 = const_reg;
      D.44499 = cfg->cbb;
      D.44500 = D.44499->last_ins;
      if (D.44500 != 0B) goto <D.44508>; else goto <D.44509>;
      <D.44508>:
      D.44499 = cfg->cbb;
      D.44500 = D.44499->last_ins;
      D.44500->next = inst;
      D.44499 = cfg->cbb;
      D.44500 = D.44499->last_ins;
      inst->prev = D.44500;
      D.44499 = cfg->cbb;
      D.44499->last_ins = inst;
      goto <D.44510>;
      <D.44509>:
      D.44499 = cfg->cbb;
      D.44499 = cfg->cbb;
      D.44499->last_ins = inst;
      D.44500 = D.44499->last_ins;
      D.44499->code = D.44500;
      <D.44510>:
    }
  }
  goto <D.44511>;
  <D.44487>:
  {
    struct MonoInst * inst;

    D.44489 = cfg->mempool;
    inst = mono_mempool_alloc (D.44489, 80);
    inst->data.op[1].const_val = 0;
    D.44512 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44512;
    inst->prev = 0B;
    D.44513 = inst->prev;
    inst->next = D.44513;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44514 = inst->sreg3;
    inst->sreg2 = D.44514;
    D.44515 = inst->sreg2;
    inst->sreg1 = D.44515;
    D.44498 = cfg->ip;
    inst->cil_code = D.44498;
    inst->dreg = -1;
    inst->sreg1 = klass_reg;
    klass.377 = (long int) klass;
    inst->data.op[1].const_val = klass.377;
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    if (D.44500 != 0B) goto <D.44517>; else goto <D.44518>;
    <D.44517>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44500->next = inst;
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    inst->prev = D.44500;
    D.44499 = cfg->cbb;
    D.44499->last_ins = inst;
    goto <D.44519>;
    <D.44518>:
    D.44499 = cfg->cbb;
    D.44499 = cfg->cbb;
    D.44499->last_ins = inst;
    D.44500 = D.44499->last_ins;
    D.44499->code = D.44500;
    <D.44519>:
  }
  <D.44511>:
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.44489 = cfg->mempool;
    ins = mono_mempool_alloc (D.44489, 80);
    ins->data.op[1].const_val = 0;
    D.44520 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.44520;
    ins->prev = 0B;
    D.44521 = ins->prev;
    ins->next = D.44521;
    D.44522 = (short unsigned int) branch_op;
    ins->opcode = D.44522;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.44523 = ins->sreg3;
    ins->sreg2 = D.44523;
    D.44524 = ins->sreg2;
    ins->sreg1 = D.44524;
    D.44498 = cfg->ip;
    ins->cil_code = D.44498;
    if (branch_op == 442) goto <D.44525>; else goto <D.44526>;
    <D.44525>:
    D.44489 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.44489, 296);
    D.44527 = cfg->num_bblocks;
    D.44528 = D.44527;
    D.44529 = D.44528 + 1;
    cfg->num_bblocks = D.44529;
    D.44530 = (int) D.44528;
    falsebb->block_num = D.44530;
    ins->data.op[0].target_block = target;
    D.44499 = cfg->cbb;
    mono_link_bblock (cfg, D.44499, target);
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    if (D.44500 != 0B) goto <D.44531>; else goto <D.44532>;
    <D.44531>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44500->next = ins;
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    ins->prev = D.44500;
    D.44499 = cfg->cbb;
    D.44499->last_ins = ins;
    goto <D.44533>;
    <D.44532>:
    D.44499 = cfg->cbb;
    D.44499 = cfg->cbb;
    D.44499->last_ins = ins;
    D.44500 = D.44499->last_ins;
    D.44499->code = D.44500;
    <D.44533>:
    D.44534 = falsebb->cil_code;
    if (D.44534 != 0B) goto <D.44535>; else goto <D.44536>;
    <D.44535>:
    D.44537 = cfg->cil_offset_to_bb;
    D.44534 = falsebb->cil_code;
    D.44538 = (long int) D.44534;
    D.44539 = cfg->cil_start;
    D.44540 = (long int) D.44539;
    D.44541 = D.44538 - D.44540;
    D.44542 = (long unsigned int) D.44541;
    D.44543 = D.44542 * 8;
    D.44544 = D.44537 + D.44543;
    *D.44544 = falsebb;
    <D.44536>:
    D.44545 = cfg->real_offset;
    falsebb->real_offset = D.44545;
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    if (D.44500 != 0B) goto <D.44549>; else goto <D.44546>;
    <D.44549>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44550 = D.44500->opcode;
    D.44551 = D.44550 + 64985;
    if (D.44551 <= 9) goto <D.44547>; else goto <D.44552>;
    <D.44552>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44550 = D.44500->opcode;
    D.44553 = D.44550 + 64878;
    if (D.44553 <= 9) goto <D.44547>; else goto <D.44554>;
    <D.44554>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44550 = D.44500->opcode;
    D.44555 = D.44550 + 64888;
    if (D.44555 <= 9) goto <D.44547>; else goto <D.44546>;
    <D.44547>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44556 = D.44500->data.op[1].many_blocks;
    D.44557 = D.44556 + 8;
    D.44558 = *D.44557;
    if (D.44558 == 0B) goto <D.44559>; else goto <D.44546>;
    <D.44559>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44556 = D.44500->data.op[1].many_blocks;
    D.44557 = D.44556 + 8;
    *D.44557 = falsebb;
    D.44499 = cfg->cbb;
    mono_link_bblock (cfg, D.44499, falsebb);
    goto <D.44548>;
    <D.44546>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    if (D.44500 == 0B) goto <D.44560>; else goto <D.44562>;
    <D.44562>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44550 = D.44500->opcode;
    if (D.44550 != 442) goto <D.44563>; else goto <D.44561>;
    <D.44563>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44550 = D.44500->opcode;
    if (D.44550 != 759) goto <D.44564>; else goto <D.44561>;
    <D.44564>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44550 = D.44500->opcode;
    D.44551 = D.44550 + 64985;
    if (D.44551 > 9) goto <D.44565>; else goto <D.44561>;
    <D.44565>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44550 = D.44500->opcode;
    D.44553 = D.44550 + 64878;
    if (D.44553 > 9) goto <D.44566>; else goto <D.44561>;
    <D.44566>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44550 = D.44500->opcode;
    D.44555 = D.44550 + 64888;
    if (D.44555 > 9) goto <D.44560>; else goto <D.44561>;
    <D.44560>:
    D.44499 = cfg->cbb;
    mono_link_bblock (cfg, D.44499, falsebb);
    <D.44561>:
    <D.44548>:
    D.44499 = cfg->cbb;
    D.44499->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.44567>;
    <D.44526>:
    D.44489 = cfg->mempool;
    D.44568 = mono_mempool_alloc (D.44489, 16);
    ins->data.op[1].many_blocks = D.44568;
    D.44569 = ins->data.op[1].many_blocks;
    *D.44569 = target;
    D.44569 = ins->data.op[1].many_blocks;
    D.44570 = D.44569 + 8;
    *D.44570 = 0B;
    D.44499 = cfg->cbb;
    mono_link_bblock (cfg, D.44499, target);
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    if (D.44500 != 0B) goto <D.44571>; else goto <D.44572>;
    <D.44571>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44500->next = ins;
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    ins->prev = D.44500;
    D.44499 = cfg->cbb;
    D.44499->last_ins = ins;
    goto <D.44573>;
    <D.44572>:
    D.44499 = cfg->cbb;
    D.44499 = cfg->cbb;
    D.44499->last_ins = ins;
    D.44500 = D.44499->last_ins;
    D.44499->code = D.44500;
    <D.44573>:
    D.44484 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.44574 = D.44484 & 268435456;
    if (D.44574 == 0) goto <D.44575>; else goto <D.44576>;
    <D.44575>:
    D.44489 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.44489, 296);
    D.44527 = cfg->num_bblocks;
    D.44577 = D.44527;
    D.44578 = D.44577 + 1;
    cfg->num_bblocks = D.44578;
    D.44579 = (int) D.44577;
    falsebb->block_num = D.44579;
    D.44569 = ins->data.op[1].many_blocks;
    D.44570 = D.44569 + 8;
    *D.44570 = falsebb;
    D.44499 = cfg->cbb;
    mono_link_bblock (cfg, D.44499, falsebb);
    D.44534 = falsebb->cil_code;
    if (D.44534 != 0B) goto <D.44580>; else goto <D.44581>;
    <D.44580>:
    D.44537 = cfg->cil_offset_to_bb;
    D.44534 = falsebb->cil_code;
    D.44538 = (long int) D.44534;
    D.44539 = cfg->cil_start;
    D.44540 = (long int) D.44539;
    D.44541 = D.44538 - D.44540;
    D.44542 = (long unsigned int) D.44541;
    D.44543 = D.44542 * 8;
    D.44544 = D.44537 + D.44543;
    *D.44544 = falsebb;
    <D.44581>:
    D.44545 = cfg->real_offset;
    falsebb->real_offset = D.44545;
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    if (D.44500 != 0B) goto <D.44585>; else goto <D.44582>;
    <D.44585>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44550 = D.44500->opcode;
    D.44551 = D.44550 + 64985;
    if (D.44551 <= 9) goto <D.44583>; else goto <D.44586>;
    <D.44586>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44550 = D.44500->opcode;
    D.44553 = D.44550 + 64878;
    if (D.44553 <= 9) goto <D.44583>; else goto <D.44587>;
    <D.44587>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44550 = D.44500->opcode;
    D.44555 = D.44550 + 64888;
    if (D.44555 <= 9) goto <D.44583>; else goto <D.44582>;
    <D.44583>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44556 = D.44500->data.op[1].many_blocks;
    D.44557 = D.44556 + 8;
    D.44558 = *D.44557;
    if (D.44558 == 0B) goto <D.44588>; else goto <D.44582>;
    <D.44588>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44556 = D.44500->data.op[1].many_blocks;
    D.44557 = D.44556 + 8;
    *D.44557 = falsebb;
    D.44499 = cfg->cbb;
    mono_link_bblock (cfg, D.44499, falsebb);
    goto <D.44584>;
    <D.44582>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    if (D.44500 == 0B) goto <D.44589>; else goto <D.44591>;
    <D.44591>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44550 = D.44500->opcode;
    if (D.44550 != 442) goto <D.44592>; else goto <D.44590>;
    <D.44592>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44550 = D.44500->opcode;
    if (D.44550 != 759) goto <D.44593>; else goto <D.44590>;
    <D.44593>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44550 = D.44500->opcode;
    D.44551 = D.44550 + 64985;
    if (D.44551 > 9) goto <D.44594>; else goto <D.44590>;
    <D.44594>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44550 = D.44500->opcode;
    D.44553 = D.44550 + 64878;
    if (D.44553 > 9) goto <D.44595>; else goto <D.44590>;
    <D.44595>:
    D.44499 = cfg->cbb;
    D.44500 = D.44499->last_ins;
    D.44550 = D.44500->opcode;
    D.44555 = D.44550 + 64888;
    if (D.44555 > 9) goto <D.44589>; else goto <D.44590>;
    <D.44589>:
    D.44499 = cfg->cbb;
    mono_link_bblock (cfg, D.44499, falsebb);
    <D.44590>:
    <D.44584>:
    D.44499 = cfg->cbb;
    D.44499->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.44596>;
    <D.44576>:
    D.44499 = cfg->cbb;
    D.44499->extended = 1;
    <D.44596>:
    <D.44567>:
  }
}


mini_emit_iface_class_cast (struct MonoCompile * cfg, int klass_reg, struct MonoClass * klass, struct MonoBasicBlock * false_target, struct MonoBasicBlock * true_target)
{
  unsigned int D.44597;
  struct MonoMemPool * D.44598;
  long int D.44599;
  struct MonoInst * D.44600;
  int D.44601;
  int D.44602;
  const unsigned char * D.44603;
  struct MonoBasicBlock * D.44604;
  struct MonoInst * D.44605;
  long int D.44611;
  struct MonoInst * D.44612;
  int D.44613;
  int D.44614;
  unsigned int D.44617;
  unsigned int D.44618;
  unsigned int D.44619;
  int D.44620;
  unsigned char * D.44624;
  struct MonoBasicBlock * * D.44627;
  long int D.44628;
  unsigned char * D.44629;
  long int D.44630;
  long int D.44631;
  long unsigned int D.44632;
  long unsigned int D.44633;
  struct MonoBasicBlock * * D.44634;
  unsigned int D.44635;
  short unsigned int D.44640;
  short unsigned int D.44641;
  short unsigned int D.44643;
  short unsigned int D.44645;
  struct MonoBasicBlock * * D.44646;
  struct MonoBasicBlock * * D.44647;
  struct MonoBasicBlock * D.44648;
  void * D.44658;
  struct MonoBasicBlock * * D.44659;
  struct MonoBasicBlock * * D.44660;
  long unsigned int D.44664;
  long unsigned int D.44665;
  unsigned int D.44668;
  unsigned int D.44669;
  int D.44670;
  long int D.44689;
  struct MonoInst * D.44690;
  int D.44691;
  int D.44692;
  int intf_bit_reg;

  D.44597 = alloc_preg (cfg);
  intf_bit_reg = (int) D.44597;
  mini_emit_max_iid_check_class (cfg, klass_reg, klass, false_target);
  mini_emit_load_intf_bit_reg_class (cfg, intf_bit_reg, klass_reg, klass);
  {
    struct MonoInst * inst;

    D.44598 = cfg->mempool;
    inst = mono_mempool_alloc (D.44598, 80);
    inst->data.op[1].const_val = 0;
    D.44599 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44599;
    inst->prev = 0B;
    D.44600 = inst->prev;
    inst->next = D.44600;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44601 = inst->sreg3;
    inst->sreg2 = D.44601;
    D.44602 = inst->sreg2;
    inst->sreg1 = D.44602;
    D.44603 = cfg->ip;
    inst->cil_code = D.44603;
    inst->dreg = -1;
    inst->sreg1 = intf_bit_reg;
    inst->data.op[1].const_val = 0;
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    if (D.44605 != 0B) goto <D.44606>; else goto <D.44607>;
    <D.44606>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44605->next = inst;
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    inst->prev = D.44605;
    D.44604 = cfg->cbb;
    D.44604->last_ins = inst;
    goto <D.44608>;
    <D.44607>:
    D.44604 = cfg->cbb;
    D.44604 = cfg->cbb;
    D.44604->last_ins = inst;
    D.44605 = D.44604->last_ins;
    D.44604->code = D.44605;
    <D.44608>:
  }
  if (true_target != 0B) goto <D.44609>; else goto <D.44610>;
  <D.44609>:
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.44598 = cfg->mempool;
    ins = mono_mempool_alloc (D.44598, 80);
    ins->data.op[1].const_val = 0;
    D.44611 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.44611;
    ins->prev = 0B;
    D.44612 = ins->prev;
    ins->next = D.44612;
    ins->opcode = 556;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.44613 = ins->sreg3;
    ins->sreg2 = D.44613;
    D.44614 = ins->sreg2;
    ins->sreg1 = D.44614;
    D.44603 = cfg->ip;
    ins->cil_code = D.44603;
    if (0 != 0) goto <D.44615>; else goto <D.44616>;
    <D.44615>:
    D.44598 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.44598, 296);
    D.44617 = cfg->num_bblocks;
    D.44618 = D.44617;
    D.44619 = D.44618 + 1;
    cfg->num_bblocks = D.44619;
    D.44620 = (int) D.44618;
    falsebb->block_num = D.44620;
    ins->data.op[0].target_block = true_target;
    D.44604 = cfg->cbb;
    mono_link_bblock (cfg, D.44604, true_target);
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    if (D.44605 != 0B) goto <D.44621>; else goto <D.44622>;
    <D.44621>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44605->next = ins;
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    ins->prev = D.44605;
    D.44604 = cfg->cbb;
    D.44604->last_ins = ins;
    goto <D.44623>;
    <D.44622>:
    D.44604 = cfg->cbb;
    D.44604 = cfg->cbb;
    D.44604->last_ins = ins;
    D.44605 = D.44604->last_ins;
    D.44604->code = D.44605;
    <D.44623>:
    D.44624 = falsebb->cil_code;
    if (D.44624 != 0B) goto <D.44625>; else goto <D.44626>;
    <D.44625>:
    D.44627 = cfg->cil_offset_to_bb;
    D.44624 = falsebb->cil_code;
    D.44628 = (long int) D.44624;
    D.44629 = cfg->cil_start;
    D.44630 = (long int) D.44629;
    D.44631 = D.44628 - D.44630;
    D.44632 = (long unsigned int) D.44631;
    D.44633 = D.44632 * 8;
    D.44634 = D.44627 + D.44633;
    *D.44634 = falsebb;
    <D.44626>:
    D.44635 = cfg->real_offset;
    falsebb->real_offset = D.44635;
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    if (D.44605 != 0B) goto <D.44639>; else goto <D.44636>;
    <D.44639>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44640 = D.44605->opcode;
    D.44641 = D.44640 + 64985;
    if (D.44641 <= 9) goto <D.44637>; else goto <D.44642>;
    <D.44642>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44640 = D.44605->opcode;
    D.44643 = D.44640 + 64878;
    if (D.44643 <= 9) goto <D.44637>; else goto <D.44644>;
    <D.44644>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44640 = D.44605->opcode;
    D.44645 = D.44640 + 64888;
    if (D.44645 <= 9) goto <D.44637>; else goto <D.44636>;
    <D.44637>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44646 = D.44605->data.op[1].many_blocks;
    D.44647 = D.44646 + 8;
    D.44648 = *D.44647;
    if (D.44648 == 0B) goto <D.44649>; else goto <D.44636>;
    <D.44649>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44646 = D.44605->data.op[1].many_blocks;
    D.44647 = D.44646 + 8;
    *D.44647 = falsebb;
    D.44604 = cfg->cbb;
    mono_link_bblock (cfg, D.44604, falsebb);
    goto <D.44638>;
    <D.44636>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    if (D.44605 == 0B) goto <D.44650>; else goto <D.44652>;
    <D.44652>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44640 = D.44605->opcode;
    if (D.44640 != 442) goto <D.44653>; else goto <D.44651>;
    <D.44653>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44640 = D.44605->opcode;
    if (D.44640 != 759) goto <D.44654>; else goto <D.44651>;
    <D.44654>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44640 = D.44605->opcode;
    D.44641 = D.44640 + 64985;
    if (D.44641 > 9) goto <D.44655>; else goto <D.44651>;
    <D.44655>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44640 = D.44605->opcode;
    D.44643 = D.44640 + 64878;
    if (D.44643 > 9) goto <D.44656>; else goto <D.44651>;
    <D.44656>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44640 = D.44605->opcode;
    D.44645 = D.44640 + 64888;
    if (D.44645 > 9) goto <D.44650>; else goto <D.44651>;
    <D.44650>:
    D.44604 = cfg->cbb;
    mono_link_bblock (cfg, D.44604, falsebb);
    <D.44651>:
    <D.44638>:
    D.44604 = cfg->cbb;
    D.44604->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.44657>;
    <D.44616>:
    D.44598 = cfg->mempool;
    D.44658 = mono_mempool_alloc (D.44598, 16);
    ins->data.op[1].many_blocks = D.44658;
    D.44659 = ins->data.op[1].many_blocks;
    *D.44659 = true_target;
    D.44659 = ins->data.op[1].many_blocks;
    D.44660 = D.44659 + 8;
    *D.44660 = 0B;
    D.44604 = cfg->cbb;
    mono_link_bblock (cfg, D.44604, true_target);
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    if (D.44605 != 0B) goto <D.44661>; else goto <D.44662>;
    <D.44661>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44605->next = ins;
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    ins->prev = D.44605;
    D.44604 = cfg->cbb;
    D.44604->last_ins = ins;
    goto <D.44663>;
    <D.44662>:
    D.44604 = cfg->cbb;
    D.44604 = cfg->cbb;
    D.44604->last_ins = ins;
    D.44605 = D.44604->last_ins;
    D.44604->code = D.44605;
    <D.44663>:
    D.44664 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.44665 = D.44664 & 268435456;
    if (D.44665 == 0) goto <D.44666>; else goto <D.44667>;
    <D.44666>:
    D.44598 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.44598, 296);
    D.44617 = cfg->num_bblocks;
    D.44668 = D.44617;
    D.44669 = D.44668 + 1;
    cfg->num_bblocks = D.44669;
    D.44670 = (int) D.44668;
    falsebb->block_num = D.44670;
    D.44659 = ins->data.op[1].many_blocks;
    D.44660 = D.44659 + 8;
    *D.44660 = falsebb;
    D.44604 = cfg->cbb;
    mono_link_bblock (cfg, D.44604, falsebb);
    D.44624 = falsebb->cil_code;
    if (D.44624 != 0B) goto <D.44671>; else goto <D.44672>;
    <D.44671>:
    D.44627 = cfg->cil_offset_to_bb;
    D.44624 = falsebb->cil_code;
    D.44628 = (long int) D.44624;
    D.44629 = cfg->cil_start;
    D.44630 = (long int) D.44629;
    D.44631 = D.44628 - D.44630;
    D.44632 = (long unsigned int) D.44631;
    D.44633 = D.44632 * 8;
    D.44634 = D.44627 + D.44633;
    *D.44634 = falsebb;
    <D.44672>:
    D.44635 = cfg->real_offset;
    falsebb->real_offset = D.44635;
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    if (D.44605 != 0B) goto <D.44676>; else goto <D.44673>;
    <D.44676>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44640 = D.44605->opcode;
    D.44641 = D.44640 + 64985;
    if (D.44641 <= 9) goto <D.44674>; else goto <D.44677>;
    <D.44677>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44640 = D.44605->opcode;
    D.44643 = D.44640 + 64878;
    if (D.44643 <= 9) goto <D.44674>; else goto <D.44678>;
    <D.44678>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44640 = D.44605->opcode;
    D.44645 = D.44640 + 64888;
    if (D.44645 <= 9) goto <D.44674>; else goto <D.44673>;
    <D.44674>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44646 = D.44605->data.op[1].many_blocks;
    D.44647 = D.44646 + 8;
    D.44648 = *D.44647;
    if (D.44648 == 0B) goto <D.44679>; else goto <D.44673>;
    <D.44679>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44646 = D.44605->data.op[1].many_blocks;
    D.44647 = D.44646 + 8;
    *D.44647 = falsebb;
    D.44604 = cfg->cbb;
    mono_link_bblock (cfg, D.44604, falsebb);
    goto <D.44675>;
    <D.44673>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    if (D.44605 == 0B) goto <D.44680>; else goto <D.44682>;
    <D.44682>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44640 = D.44605->opcode;
    if (D.44640 != 442) goto <D.44683>; else goto <D.44681>;
    <D.44683>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44640 = D.44605->opcode;
    if (D.44640 != 759) goto <D.44684>; else goto <D.44681>;
    <D.44684>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44640 = D.44605->opcode;
    D.44641 = D.44640 + 64985;
    if (D.44641 > 9) goto <D.44685>; else goto <D.44681>;
    <D.44685>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44640 = D.44605->opcode;
    D.44643 = D.44640 + 64878;
    if (D.44643 > 9) goto <D.44686>; else goto <D.44681>;
    <D.44686>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44640 = D.44605->opcode;
    D.44645 = D.44640 + 64888;
    if (D.44645 > 9) goto <D.44680>; else goto <D.44681>;
    <D.44680>:
    D.44604 = cfg->cbb;
    mono_link_bblock (cfg, D.44604, falsebb);
    <D.44681>:
    <D.44675>:
    D.44604 = cfg->cbb;
    D.44604->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.44687>;
    <D.44667>:
    D.44604 = cfg->cbb;
    D.44604->extended = 1;
    <D.44687>:
    <D.44657>:
  }
  goto <D.44688>;
  <D.44610>:
  {
    struct MonoInst * inst;

    D.44598 = cfg->mempool;
    inst = mono_mempool_alloc (D.44598, 80);
    inst->data.op[1].const_val = 0;
    D.44689 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44689;
    inst->prev = 0B;
    D.44690 = inst->prev;
    inst->next = D.44690;
    inst->opcode = 451;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44691 = inst->sreg3;
    inst->sreg2 = D.44691;
    D.44692 = inst->sreg2;
    inst->sreg1 = D.44692;
    D.44603 = cfg->ip;
    inst->cil_code = D.44603;
    inst->data.op[1].p = "InvalidCastException";
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    if (D.44605 != 0B) goto <D.44693>; else goto <D.44694>;
    <D.44693>:
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    D.44605->next = inst;
    D.44604 = cfg->cbb;
    D.44605 = D.44604->last_ins;
    inst->prev = D.44605;
    D.44604 = cfg->cbb;
    D.44604->last_ins = inst;
    goto <D.44695>;
    <D.44694>:
    D.44604 = cfg->cbb;
    D.44604 = cfg->cbb;
    D.44604->last_ins = inst;
    D.44605 = D.44604->last_ins;
    D.44604->code = D.44605;
    <D.44695>:
  }
  <D.44688>:
}


mini_emit_max_iid_check_class (struct MonoCompile * cfg, int klass_reg, struct MonoClass * klass, struct MonoBasicBlock * false_target)
{
  unsigned int D.44696;
  struct MonoMemPool * D.44697;
  long int D.44698;
  struct MonoInst * D.44699;
  int D.44700;
  int D.44701;
  const unsigned char * D.44702;
  struct MonoBasicBlock * D.44703;
  struct MonoInst * D.44704;
  int max_iid_reg;

  D.44696 = alloc_preg (cfg);
  max_iid_reg = (int) D.44696;
  {
    struct MonoInst * inst;

    D.44697 = cfg->mempool;
    inst = mono_mempool_alloc (D.44697, 80);
    inst->data.op[1].const_val = 0;
    D.44698 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44698;
    inst->prev = 0B;
    D.44699 = inst->prev;
    inst->next = D.44699;
    inst->opcode = 392;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44700 = inst->sreg3;
    inst->sreg2 = D.44700;
    D.44701 = inst->sreg2;
    inst->sreg1 = D.44701;
    D.44702 = cfg->ip;
    inst->cil_code = D.44702;
    inst->dreg = max_iid_reg;
    inst->sreg1 = klass_reg;
    inst->data.op[0].const_val = 92;
    D.44703 = cfg->cbb;
    D.44704 = D.44703->last_ins;
    if (D.44704 != 0B) goto <D.44705>; else goto <D.44706>;
    <D.44705>:
    D.44703 = cfg->cbb;
    D.44704 = D.44703->last_ins;
    D.44704->next = inst;
    D.44703 = cfg->cbb;
    D.44704 = D.44703->last_ins;
    inst->prev = D.44704;
    D.44703 = cfg->cbb;
    D.44703->last_ins = inst;
    goto <D.44707>;
    <D.44706>:
    D.44703 = cfg->cbb;
    D.44703 = cfg->cbb;
    D.44703->last_ins = inst;
    D.44704 = D.44703->last_ins;
    D.44703->code = D.44704;
    <D.44707>:
  }
  mini_emit_max_iid_check (cfg, max_iid_reg, klass, false_target);
}


mini_emit_load_intf_bit_reg_class (struct MonoCompile * cfg, int intf_bit_reg, int klass_reg, struct MonoClass * klass)
{
  mini_emit_interface_bitmap_check (cfg, intf_bit_reg, klass_reg, 112, klass);
}


mini_emit_isninst_cast (struct MonoCompile * cfg, int klass_reg, struct MonoClass * klass, struct MonoBasicBlock * false_target, struct MonoBasicBlock * true_target)
{
  mini_emit_isninst_cast_inst (cfg, klass_reg, klass, 0B, false_target, true_target);
}


mini_emit_isninst_cast_inst (struct MonoCompile * cfg, int klass_reg, struct MonoClass * klass, struct MonoInst * klass_ins, struct MonoBasicBlock * false_target, struct MonoBasicBlock * true_target)
{
  unsigned int D.44708;
  unsigned int D.44709;
  unsigned int D.44710;
  short unsigned int D.44711;
  struct MonoMemPool * D.44714;
  long int D.44715;
  struct MonoInst * D.44716;
  int D.44717;
  int D.44718;
  const unsigned char * D.44719;
  struct MonoBasicBlock * D.44720;
  struct MonoInst * D.44721;
  long int D.44725;
  struct MonoInst * D.44726;
  int D.44727;
  int D.44728;
  long int D.44729;
  long int D.44733;
  struct MonoInst * D.44734;
  int D.44735;
  int D.44736;
  unsigned int D.44739;
  unsigned int D.44740;
  unsigned int D.44741;
  int D.44742;
  unsigned char * D.44746;
  struct MonoBasicBlock * * D.44749;
  long int D.44750;
  unsigned char * D.44751;
  long int D.44752;
  long int D.44753;
  long unsigned int D.44754;
  long unsigned int D.44755;
  struct MonoBasicBlock * * D.44756;
  unsigned int D.44757;
  short unsigned int D.44762;
  short unsigned int D.44763;
  short unsigned int D.44765;
  short unsigned int D.44767;
  struct MonoBasicBlock * * D.44768;
  struct MonoBasicBlock * * D.44769;
  struct MonoBasicBlock * D.44770;
  void * D.44780;
  struct MonoBasicBlock * * D.44781;
  struct MonoBasicBlock * * D.44782;
  long unsigned int D.44786;
  long unsigned int D.44787;
  unsigned int D.44790;
  unsigned int D.44791;
  int D.44792;
  long int D.44810;
  struct MonoInst * D.44811;
  int D.44812;
  int D.44813;
  long int D.44817;
  struct MonoInst * D.44818;
  int D.44819;
  int D.44820;
  int D.44821;
  int D.44822;
  int D.44823;
  long int D.44824;
  long int D.44830;
  struct MonoInst * D.44831;
  int D.44832;
  int D.44833;
  int D.44834;
  long unsigned int D.44839;
  unsigned int D.44842;
  long int D.44843;
  struct MonoInst * D.44844;
  guint16 iftmp.378;
  int D.44849;
  int D.44850;
  long int D.44854;
  struct MonoInst * D.44855;
  int D.44856;
  int D.44857;
  long int D.44862;
  struct MonoInst * D.44863;
  int D.44864;
  int D.44865;
  long int klass.379;
  long int D.44870;
  struct MonoInst * D.44871;
  int D.44872;
  int D.44873;
  unsigned int D.44876;
  unsigned int D.44877;
  int D.44878;
  unsigned char * D.44882;
  long int D.44885;
  long int D.44886;
  long unsigned int D.44887;
  long unsigned int D.44888;
  struct MonoBasicBlock * * D.44889;
  void * D.44905;
  struct MonoBasicBlock * * D.44906;
  struct MonoBasicBlock * * D.44907;
  unsigned int D.44913;
  unsigned int D.44914;
  int D.44915;
  int idepth_reg;
  int stypes_reg;
  int stype;

  D.44708 = alloc_preg (cfg);
  idepth_reg = (int) D.44708;
  D.44709 = alloc_preg (cfg);
  stypes_reg = (int) D.44709;
  D.44710 = alloc_preg (cfg);
  stype = (int) D.44710;
  mono_class_setup_supertypes (klass);
  D.44711 = klass->idepth;
  if (D.44711 > 6) goto <D.44712>; else goto <D.44713>;
  <D.44712>:
  {
    struct MonoInst * inst;

    D.44714 = cfg->mempool;
    inst = mono_mempool_alloc (D.44714, 80);
    inst->data.op[1].const_val = 0;
    D.44715 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44715;
    inst->prev = 0B;
    D.44716 = inst->prev;
    inst->next = D.44716;
    inst->opcode = 392;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44717 = inst->sreg3;
    inst->sreg2 = D.44717;
    D.44718 = inst->sreg2;
    inst->sreg1 = D.44718;
    D.44719 = cfg->ip;
    inst->cil_code = D.44719;
    inst->dreg = idepth_reg;
    inst->sreg1 = klass_reg;
    inst->data.op[0].const_val = 24;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    if (D.44721 != 0B) goto <D.44722>; else goto <D.44723>;
    <D.44722>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44721->next = inst;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    inst->prev = D.44721;
    D.44720 = cfg->cbb;
    D.44720->last_ins = inst;
    goto <D.44724>;
    <D.44723>:
    D.44720 = cfg->cbb;
    D.44720 = cfg->cbb;
    D.44720->last_ins = inst;
    D.44721 = D.44720->last_ins;
    D.44720->code = D.44721;
    <D.44724>:
  }
  {
    struct MonoInst * inst;

    D.44714 = cfg->mempool;
    inst = mono_mempool_alloc (D.44714, 80);
    inst->data.op[1].const_val = 0;
    D.44725 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44725;
    inst->prev = 0B;
    D.44726 = inst->prev;
    inst->next = D.44726;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44727 = inst->sreg3;
    inst->sreg2 = D.44727;
    D.44728 = inst->sreg2;
    inst->sreg1 = D.44728;
    D.44719 = cfg->ip;
    inst->cil_code = D.44719;
    inst->dreg = -1;
    inst->sreg1 = idepth_reg;
    D.44711 = klass->idepth;
    D.44729 = (long int) D.44711;
    inst->data.op[1].const_val = D.44729;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    if (D.44721 != 0B) goto <D.44730>; else goto <D.44731>;
    <D.44730>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44721->next = inst;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    inst->prev = D.44721;
    D.44720 = cfg->cbb;
    D.44720->last_ins = inst;
    goto <D.44732>;
    <D.44731>:
    D.44720 = cfg->cbb;
    D.44720 = cfg->cbb;
    D.44720->last_ins = inst;
    D.44721 = D.44720->last_ins;
    D.44720->code = D.44721;
    <D.44732>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.44714 = cfg->mempool;
    ins = mono_mempool_alloc (D.44714, 80);
    ins->data.op[1].const_val = 0;
    D.44733 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.44733;
    ins->prev = 0B;
    D.44734 = ins->prev;
    ins->next = D.44734;
    ins->opcode = 560;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.44735 = ins->sreg3;
    ins->sreg2 = D.44735;
    D.44736 = ins->sreg2;
    ins->sreg1 = D.44736;
    D.44719 = cfg->ip;
    ins->cil_code = D.44719;
    if (0 != 0) goto <D.44737>; else goto <D.44738>;
    <D.44737>:
    D.44714 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.44714, 296);
    D.44739 = cfg->num_bblocks;
    D.44740 = D.44739;
    D.44741 = D.44740 + 1;
    cfg->num_bblocks = D.44741;
    D.44742 = (int) D.44740;
    falsebb->block_num = D.44742;
    ins->data.op[0].target_block = false_target;
    D.44720 = cfg->cbb;
    mono_link_bblock (cfg, D.44720, false_target);
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    if (D.44721 != 0B) goto <D.44743>; else goto <D.44744>;
    <D.44743>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44721->next = ins;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    ins->prev = D.44721;
    D.44720 = cfg->cbb;
    D.44720->last_ins = ins;
    goto <D.44745>;
    <D.44744>:
    D.44720 = cfg->cbb;
    D.44720 = cfg->cbb;
    D.44720->last_ins = ins;
    D.44721 = D.44720->last_ins;
    D.44720->code = D.44721;
    <D.44745>:
    D.44746 = falsebb->cil_code;
    if (D.44746 != 0B) goto <D.44747>; else goto <D.44748>;
    <D.44747>:
    D.44749 = cfg->cil_offset_to_bb;
    D.44746 = falsebb->cil_code;
    D.44750 = (long int) D.44746;
    D.44751 = cfg->cil_start;
    D.44752 = (long int) D.44751;
    D.44753 = D.44750 - D.44752;
    D.44754 = (long unsigned int) D.44753;
    D.44755 = D.44754 * 8;
    D.44756 = D.44749 + D.44755;
    *D.44756 = falsebb;
    <D.44748>:
    D.44757 = cfg->real_offset;
    falsebb->real_offset = D.44757;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    if (D.44721 != 0B) goto <D.44761>; else goto <D.44758>;
    <D.44761>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44763 = D.44762 + 64985;
    if (D.44763 <= 9) goto <D.44759>; else goto <D.44764>;
    <D.44764>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44765 = D.44762 + 64878;
    if (D.44765 <= 9) goto <D.44759>; else goto <D.44766>;
    <D.44766>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44767 = D.44762 + 64888;
    if (D.44767 <= 9) goto <D.44759>; else goto <D.44758>;
    <D.44759>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44768 = D.44721->data.op[1].many_blocks;
    D.44769 = D.44768 + 8;
    D.44770 = *D.44769;
    if (D.44770 == 0B) goto <D.44771>; else goto <D.44758>;
    <D.44771>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44768 = D.44721->data.op[1].many_blocks;
    D.44769 = D.44768 + 8;
    *D.44769 = falsebb;
    D.44720 = cfg->cbb;
    mono_link_bblock (cfg, D.44720, falsebb);
    goto <D.44760>;
    <D.44758>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    if (D.44721 == 0B) goto <D.44772>; else goto <D.44774>;
    <D.44774>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    if (D.44762 != 442) goto <D.44775>; else goto <D.44773>;
    <D.44775>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    if (D.44762 != 759) goto <D.44776>; else goto <D.44773>;
    <D.44776>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44763 = D.44762 + 64985;
    if (D.44763 > 9) goto <D.44777>; else goto <D.44773>;
    <D.44777>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44765 = D.44762 + 64878;
    if (D.44765 > 9) goto <D.44778>; else goto <D.44773>;
    <D.44778>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44767 = D.44762 + 64888;
    if (D.44767 > 9) goto <D.44772>; else goto <D.44773>;
    <D.44772>:
    D.44720 = cfg->cbb;
    mono_link_bblock (cfg, D.44720, falsebb);
    <D.44773>:
    <D.44760>:
    D.44720 = cfg->cbb;
    D.44720->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.44779>;
    <D.44738>:
    D.44714 = cfg->mempool;
    D.44780 = mono_mempool_alloc (D.44714, 16);
    ins->data.op[1].many_blocks = D.44780;
    D.44781 = ins->data.op[1].many_blocks;
    *D.44781 = false_target;
    D.44781 = ins->data.op[1].many_blocks;
    D.44782 = D.44781 + 8;
    *D.44782 = 0B;
    D.44720 = cfg->cbb;
    mono_link_bblock (cfg, D.44720, false_target);
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    if (D.44721 != 0B) goto <D.44783>; else goto <D.44784>;
    <D.44783>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44721->next = ins;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    ins->prev = D.44721;
    D.44720 = cfg->cbb;
    D.44720->last_ins = ins;
    goto <D.44785>;
    <D.44784>:
    D.44720 = cfg->cbb;
    D.44720 = cfg->cbb;
    D.44720->last_ins = ins;
    D.44721 = D.44720->last_ins;
    D.44720->code = D.44721;
    <D.44785>:
    D.44786 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.44787 = D.44786 & 268435456;
    if (D.44787 == 0) goto <D.44788>; else goto <D.44789>;
    <D.44788>:
    D.44714 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.44714, 296);
    D.44739 = cfg->num_bblocks;
    D.44790 = D.44739;
    D.44791 = D.44790 + 1;
    cfg->num_bblocks = D.44791;
    D.44792 = (int) D.44790;
    falsebb->block_num = D.44792;
    D.44781 = ins->data.op[1].many_blocks;
    D.44782 = D.44781 + 8;
    *D.44782 = falsebb;
    D.44720 = cfg->cbb;
    mono_link_bblock (cfg, D.44720, falsebb);
    D.44746 = falsebb->cil_code;
    if (D.44746 != 0B) goto <D.44793>; else goto <D.44794>;
    <D.44793>:
    D.44749 = cfg->cil_offset_to_bb;
    D.44746 = falsebb->cil_code;
    D.44750 = (long int) D.44746;
    D.44751 = cfg->cil_start;
    D.44752 = (long int) D.44751;
    D.44753 = D.44750 - D.44752;
    D.44754 = (long unsigned int) D.44753;
    D.44755 = D.44754 * 8;
    D.44756 = D.44749 + D.44755;
    *D.44756 = falsebb;
    <D.44794>:
    D.44757 = cfg->real_offset;
    falsebb->real_offset = D.44757;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    if (D.44721 != 0B) goto <D.44798>; else goto <D.44795>;
    <D.44798>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44763 = D.44762 + 64985;
    if (D.44763 <= 9) goto <D.44796>; else goto <D.44799>;
    <D.44799>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44765 = D.44762 + 64878;
    if (D.44765 <= 9) goto <D.44796>; else goto <D.44800>;
    <D.44800>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44767 = D.44762 + 64888;
    if (D.44767 <= 9) goto <D.44796>; else goto <D.44795>;
    <D.44796>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44768 = D.44721->data.op[1].many_blocks;
    D.44769 = D.44768 + 8;
    D.44770 = *D.44769;
    if (D.44770 == 0B) goto <D.44801>; else goto <D.44795>;
    <D.44801>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44768 = D.44721->data.op[1].many_blocks;
    D.44769 = D.44768 + 8;
    *D.44769 = falsebb;
    D.44720 = cfg->cbb;
    mono_link_bblock (cfg, D.44720, falsebb);
    goto <D.44797>;
    <D.44795>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    if (D.44721 == 0B) goto <D.44802>; else goto <D.44804>;
    <D.44804>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    if (D.44762 != 442) goto <D.44805>; else goto <D.44803>;
    <D.44805>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    if (D.44762 != 759) goto <D.44806>; else goto <D.44803>;
    <D.44806>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44763 = D.44762 + 64985;
    if (D.44763 > 9) goto <D.44807>; else goto <D.44803>;
    <D.44807>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44765 = D.44762 + 64878;
    if (D.44765 > 9) goto <D.44808>; else goto <D.44803>;
    <D.44808>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44767 = D.44762 + 64888;
    if (D.44767 > 9) goto <D.44802>; else goto <D.44803>;
    <D.44802>:
    D.44720 = cfg->cbb;
    mono_link_bblock (cfg, D.44720, falsebb);
    <D.44803>:
    <D.44797>:
    D.44720 = cfg->cbb;
    D.44720->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.44809>;
    <D.44789>:
    D.44720 = cfg->cbb;
    D.44720->extended = 1;
    <D.44809>:
    <D.44779>:
  }
  <D.44713>:
  {
    struct MonoInst * inst;

    D.44714 = cfg->mempool;
    inst = mono_mempool_alloc (D.44714, 80);
    inst->data.op[1].const_val = 0;
    D.44810 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44810;
    inst->prev = 0B;
    D.44811 = inst->prev;
    inst->next = D.44811;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44812 = inst->sreg3;
    inst->sreg2 = D.44812;
    D.44813 = inst->sreg2;
    inst->sreg1 = D.44813;
    D.44719 = cfg->ip;
    inst->cil_code = D.44719;
    inst->dreg = stypes_reg;
    inst->sreg1 = klass_reg;
    inst->data.op[0].const_val = 16;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    if (D.44721 != 0B) goto <D.44814>; else goto <D.44815>;
    <D.44814>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44721->next = inst;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    inst->prev = D.44721;
    D.44720 = cfg->cbb;
    D.44720->last_ins = inst;
    goto <D.44816>;
    <D.44815>:
    D.44720 = cfg->cbb;
    D.44720 = cfg->cbb;
    D.44720->last_ins = inst;
    D.44721 = D.44720->last_ins;
    D.44720->code = D.44721;
    <D.44816>:
  }
  {
    struct MonoInst * inst;

    D.44714 = cfg->mempool;
    inst = mono_mempool_alloc (D.44714, 80);
    inst->data.op[1].const_val = 0;
    D.44817 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44817;
    inst->prev = 0B;
    D.44818 = inst->prev;
    inst->next = D.44818;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44819 = inst->sreg3;
    inst->sreg2 = D.44819;
    D.44820 = inst->sreg2;
    inst->sreg1 = D.44820;
    D.44719 = cfg->ip;
    inst->cil_code = D.44719;
    inst->dreg = stype;
    inst->sreg1 = stypes_reg;
    D.44711 = klass->idepth;
    D.44821 = (int) D.44711;
    D.44822 = D.44821 + -1;
    D.44823 = D.44822 * 8;
    D.44824 = (long int) D.44823;
    inst->data.op[0].const_val = D.44824;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    if (D.44721 != 0B) goto <D.44825>; else goto <D.44826>;
    <D.44825>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44721->next = inst;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    inst->prev = D.44721;
    D.44720 = cfg->cbb;
    D.44720->last_ins = inst;
    goto <D.44827>;
    <D.44826>:
    D.44720 = cfg->cbb;
    D.44720 = cfg->cbb;
    D.44720->last_ins = inst;
    D.44721 = D.44720->last_ins;
    D.44720->code = D.44721;
    <D.44827>:
  }
  if (klass_ins != 0B) goto <D.44828>; else goto <D.44829>;
  <D.44828>:
  {
    struct MonoInst * inst;

    D.44714 = cfg->mempool;
    inst = mono_mempool_alloc (D.44714, 80);
    inst->data.op[1].const_val = 0;
    D.44830 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44830;
    inst->prev = 0B;
    D.44831 = inst->prev;
    inst->next = D.44831;
    inst->opcode = 322;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44832 = inst->sreg3;
    inst->sreg2 = D.44832;
    D.44833 = inst->sreg2;
    inst->sreg1 = D.44833;
    D.44719 = cfg->ip;
    inst->cil_code = D.44719;
    inst->dreg = -1;
    inst->sreg1 = stype;
    D.44834 = klass_ins->dreg;
    inst->sreg2 = D.44834;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    if (D.44721 != 0B) goto <D.44835>; else goto <D.44836>;
    <D.44835>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44721->next = inst;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    inst->prev = D.44721;
    D.44720 = cfg->cbb;
    D.44720->last_ins = inst;
    goto <D.44837>;
    <D.44836>:
    D.44720 = cfg->cbb;
    D.44720 = cfg->cbb;
    D.44720->last_ins = inst;
    D.44721 = D.44720->last_ins;
    D.44720->code = D.44721;
    <D.44837>:
  }
  goto <D.44838>;
  <D.44829>:
  D.44786 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.44839 = D.44786 & 33554432;
  if (D.44839 != 0) goto <D.44840>; else goto <D.44841>;
  <D.44840>:
  {
    int const_reg;

    D.44842 = alloc_preg (cfg);
    const_reg = (int) D.44842;
    {
      struct MonoInst * inst;

      D.44714 = cfg->mempool;
      inst = mono_mempool_alloc (D.44714, 80);
      inst->data.op[1].const_val = 0;
      D.44843 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.44843;
      inst->prev = 0B;
      D.44844 = inst->prev;
      inst->next = D.44844;
      D.44786 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.44839 = D.44786 & 33554432;
      if (D.44839 != 0) goto <D.44846>; else goto <D.44847>;
      <D.44846>:
      iftmp.378 = 732;
      goto <D.44848>;
      <D.44847>:
      iftmp.378 = 363;
      <D.44848>:
      inst->opcode = iftmp.378;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.44849 = inst->sreg3;
      inst->sreg2 = D.44849;
      D.44850 = inst->sreg2;
      inst->sreg1 = D.44850;
      D.44719 = cfg->ip;
      inst->cil_code = D.44719;
      inst->dreg = const_reg;
      inst->data.op[0].p = klass;
      inst->data.op[1].const_val = 11;
      D.44720 = cfg->cbb;
      D.44721 = D.44720->last_ins;
      if (D.44721 != 0B) goto <D.44851>; else goto <D.44852>;
      <D.44851>:
      D.44720 = cfg->cbb;
      D.44721 = D.44720->last_ins;
      D.44721->next = inst;
      D.44720 = cfg->cbb;
      D.44721 = D.44720->last_ins;
      inst->prev = D.44721;
      D.44720 = cfg->cbb;
      D.44720->last_ins = inst;
      goto <D.44853>;
      <D.44852>:
      D.44720 = cfg->cbb;
      D.44720 = cfg->cbb;
      D.44720->last_ins = inst;
      D.44721 = D.44720->last_ins;
      D.44720->code = D.44721;
      <D.44853>:
    }
    {
      struct MonoInst * inst;

      D.44714 = cfg->mempool;
      inst = mono_mempool_alloc (D.44714, 80);
      inst->data.op[1].const_val = 0;
      D.44854 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.44854;
      inst->prev = 0B;
      D.44855 = inst->prev;
      inst->next = D.44855;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.44856 = inst->sreg3;
      inst->sreg2 = D.44856;
      D.44857 = inst->sreg2;
      inst->sreg1 = D.44857;
      D.44719 = cfg->ip;
      inst->cil_code = D.44719;
      inst->dreg = -1;
      inst->sreg1 = stype;
      inst->sreg2 = const_reg;
      D.44720 = cfg->cbb;
      D.44721 = D.44720->last_ins;
      if (D.44721 != 0B) goto <D.44858>; else goto <D.44859>;
      <D.44858>:
      D.44720 = cfg->cbb;
      D.44721 = D.44720->last_ins;
      D.44721->next = inst;
      D.44720 = cfg->cbb;
      D.44721 = D.44720->last_ins;
      inst->prev = D.44721;
      D.44720 = cfg->cbb;
      D.44720->last_ins = inst;
      goto <D.44860>;
      <D.44859>:
      D.44720 = cfg->cbb;
      D.44720 = cfg->cbb;
      D.44720->last_ins = inst;
      D.44721 = D.44720->last_ins;
      D.44720->code = D.44721;
      <D.44860>:
    }
  }
  goto <D.44861>;
  <D.44841>:
  {
    struct MonoInst * inst;

    D.44714 = cfg->mempool;
    inst = mono_mempool_alloc (D.44714, 80);
    inst->data.op[1].const_val = 0;
    D.44862 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.44862;
    inst->prev = 0B;
    D.44863 = inst->prev;
    inst->next = D.44863;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.44864 = inst->sreg3;
    inst->sreg2 = D.44864;
    D.44865 = inst->sreg2;
    inst->sreg1 = D.44865;
    D.44719 = cfg->ip;
    inst->cil_code = D.44719;
    inst->dreg = -1;
    inst->sreg1 = stype;
    klass.379 = (long int) klass;
    inst->data.op[1].const_val = klass.379;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    if (D.44721 != 0B) goto <D.44867>; else goto <D.44868>;
    <D.44867>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44721->next = inst;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    inst->prev = D.44721;
    D.44720 = cfg->cbb;
    D.44720->last_ins = inst;
    goto <D.44869>;
    <D.44868>:
    D.44720 = cfg->cbb;
    D.44720 = cfg->cbb;
    D.44720->last_ins = inst;
    D.44721 = D.44720->last_ins;
    D.44720->code = D.44721;
    <D.44869>:
  }
  <D.44861>:
  <D.44838>:
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.44714 = cfg->mempool;
    ins = mono_mempool_alloc (D.44714, 80);
    ins->data.op[1].const_val = 0;
    D.44870 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.44870;
    ins->prev = 0B;
    D.44871 = ins->prev;
    ins->next = D.44871;
    ins->opcode = 551;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.44872 = ins->sreg3;
    ins->sreg2 = D.44872;
    D.44873 = ins->sreg2;
    ins->sreg1 = D.44873;
    D.44719 = cfg->ip;
    ins->cil_code = D.44719;
    if (0 != 0) goto <D.44874>; else goto <D.44875>;
    <D.44874>:
    D.44714 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.44714, 296);
    D.44739 = cfg->num_bblocks;
    D.44876 = D.44739;
    D.44877 = D.44876 + 1;
    cfg->num_bblocks = D.44877;
    D.44878 = (int) D.44876;
    falsebb->block_num = D.44878;
    ins->data.op[0].target_block = true_target;
    D.44720 = cfg->cbb;
    mono_link_bblock (cfg, D.44720, true_target);
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    if (D.44721 != 0B) goto <D.44879>; else goto <D.44880>;
    <D.44879>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44721->next = ins;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    ins->prev = D.44721;
    D.44720 = cfg->cbb;
    D.44720->last_ins = ins;
    goto <D.44881>;
    <D.44880>:
    D.44720 = cfg->cbb;
    D.44720 = cfg->cbb;
    D.44720->last_ins = ins;
    D.44721 = D.44720->last_ins;
    D.44720->code = D.44721;
    <D.44881>:
    D.44882 = falsebb->cil_code;
    if (D.44882 != 0B) goto <D.44883>; else goto <D.44884>;
    <D.44883>:
    D.44749 = cfg->cil_offset_to_bb;
    D.44882 = falsebb->cil_code;
    D.44885 = (long int) D.44882;
    D.44751 = cfg->cil_start;
    D.44752 = (long int) D.44751;
    D.44886 = D.44885 - D.44752;
    D.44887 = (long unsigned int) D.44886;
    D.44888 = D.44887 * 8;
    D.44889 = D.44749 + D.44888;
    *D.44889 = falsebb;
    <D.44884>:
    D.44757 = cfg->real_offset;
    falsebb->real_offset = D.44757;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    if (D.44721 != 0B) goto <D.44893>; else goto <D.44890>;
    <D.44893>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44763 = D.44762 + 64985;
    if (D.44763 <= 9) goto <D.44891>; else goto <D.44894>;
    <D.44894>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44765 = D.44762 + 64878;
    if (D.44765 <= 9) goto <D.44891>; else goto <D.44895>;
    <D.44895>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44767 = D.44762 + 64888;
    if (D.44767 <= 9) goto <D.44891>; else goto <D.44890>;
    <D.44891>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44768 = D.44721->data.op[1].many_blocks;
    D.44769 = D.44768 + 8;
    D.44770 = *D.44769;
    if (D.44770 == 0B) goto <D.44896>; else goto <D.44890>;
    <D.44896>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44768 = D.44721->data.op[1].many_blocks;
    D.44769 = D.44768 + 8;
    *D.44769 = falsebb;
    D.44720 = cfg->cbb;
    mono_link_bblock (cfg, D.44720, falsebb);
    goto <D.44892>;
    <D.44890>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    if (D.44721 == 0B) goto <D.44897>; else goto <D.44899>;
    <D.44899>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    if (D.44762 != 442) goto <D.44900>; else goto <D.44898>;
    <D.44900>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    if (D.44762 != 759) goto <D.44901>; else goto <D.44898>;
    <D.44901>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44763 = D.44762 + 64985;
    if (D.44763 > 9) goto <D.44902>; else goto <D.44898>;
    <D.44902>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44765 = D.44762 + 64878;
    if (D.44765 > 9) goto <D.44903>; else goto <D.44898>;
    <D.44903>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44767 = D.44762 + 64888;
    if (D.44767 > 9) goto <D.44897>; else goto <D.44898>;
    <D.44897>:
    D.44720 = cfg->cbb;
    mono_link_bblock (cfg, D.44720, falsebb);
    <D.44898>:
    <D.44892>:
    D.44720 = cfg->cbb;
    D.44720->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.44904>;
    <D.44875>:
    D.44714 = cfg->mempool;
    D.44905 = mono_mempool_alloc (D.44714, 16);
    ins->data.op[1].many_blocks = D.44905;
    D.44906 = ins->data.op[1].many_blocks;
    *D.44906 = true_target;
    D.44906 = ins->data.op[1].many_blocks;
    D.44907 = D.44906 + 8;
    *D.44907 = 0B;
    D.44720 = cfg->cbb;
    mono_link_bblock (cfg, D.44720, true_target);
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    if (D.44721 != 0B) goto <D.44908>; else goto <D.44909>;
    <D.44908>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44721->next = ins;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    ins->prev = D.44721;
    D.44720 = cfg->cbb;
    D.44720->last_ins = ins;
    goto <D.44910>;
    <D.44909>:
    D.44720 = cfg->cbb;
    D.44720 = cfg->cbb;
    D.44720->last_ins = ins;
    D.44721 = D.44720->last_ins;
    D.44720->code = D.44721;
    <D.44910>:
    D.44786 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.44787 = D.44786 & 268435456;
    if (D.44787 == 0) goto <D.44911>; else goto <D.44912>;
    <D.44911>:
    D.44714 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.44714, 296);
    D.44739 = cfg->num_bblocks;
    D.44913 = D.44739;
    D.44914 = D.44913 + 1;
    cfg->num_bblocks = D.44914;
    D.44915 = (int) D.44913;
    falsebb->block_num = D.44915;
    D.44906 = ins->data.op[1].many_blocks;
    D.44907 = D.44906 + 8;
    *D.44907 = falsebb;
    D.44720 = cfg->cbb;
    mono_link_bblock (cfg, D.44720, falsebb);
    D.44882 = falsebb->cil_code;
    if (D.44882 != 0B) goto <D.44916>; else goto <D.44917>;
    <D.44916>:
    D.44749 = cfg->cil_offset_to_bb;
    D.44882 = falsebb->cil_code;
    D.44885 = (long int) D.44882;
    D.44751 = cfg->cil_start;
    D.44752 = (long int) D.44751;
    D.44886 = D.44885 - D.44752;
    D.44887 = (long unsigned int) D.44886;
    D.44888 = D.44887 * 8;
    D.44889 = D.44749 + D.44888;
    *D.44889 = falsebb;
    <D.44917>:
    D.44757 = cfg->real_offset;
    falsebb->real_offset = D.44757;
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    if (D.44721 != 0B) goto <D.44921>; else goto <D.44918>;
    <D.44921>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44763 = D.44762 + 64985;
    if (D.44763 <= 9) goto <D.44919>; else goto <D.44922>;
    <D.44922>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44765 = D.44762 + 64878;
    if (D.44765 <= 9) goto <D.44919>; else goto <D.44923>;
    <D.44923>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44767 = D.44762 + 64888;
    if (D.44767 <= 9) goto <D.44919>; else goto <D.44918>;
    <D.44919>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44768 = D.44721->data.op[1].many_blocks;
    D.44769 = D.44768 + 8;
    D.44770 = *D.44769;
    if (D.44770 == 0B) goto <D.44924>; else goto <D.44918>;
    <D.44924>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44768 = D.44721->data.op[1].many_blocks;
    D.44769 = D.44768 + 8;
    *D.44769 = falsebb;
    D.44720 = cfg->cbb;
    mono_link_bblock (cfg, D.44720, falsebb);
    goto <D.44920>;
    <D.44918>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    if (D.44721 == 0B) goto <D.44925>; else goto <D.44927>;
    <D.44927>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    if (D.44762 != 442) goto <D.44928>; else goto <D.44926>;
    <D.44928>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    if (D.44762 != 759) goto <D.44929>; else goto <D.44926>;
    <D.44929>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44763 = D.44762 + 64985;
    if (D.44763 > 9) goto <D.44930>; else goto <D.44926>;
    <D.44930>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44765 = D.44762 + 64878;
    if (D.44765 > 9) goto <D.44931>; else goto <D.44926>;
    <D.44931>:
    D.44720 = cfg->cbb;
    D.44721 = D.44720->last_ins;
    D.44762 = D.44721->opcode;
    D.44767 = D.44762 + 64888;
    if (D.44767 > 9) goto <D.44925>; else goto <D.44926>;
    <D.44925>:
    D.44720 = cfg->cbb;
    mono_link_bblock (cfg, D.44720, falsebb);
    <D.44926>:
    <D.44920>:
    D.44720 = cfg->cbb;
    D.44720->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.44932>;
    <D.44912>:
    D.44720 = cfg->cbb;
    D.44720->extended = 1;
    <D.44932>:
    <D.44904>:
  }
}


handle_unbox_gsharedvt (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * obj, struct MonoBasicBlock * * out_cbb)
{
  struct MonoInst * obj.380;
  struct MonoInst * obj.381;
  struct MonoMemPool * D.44935;
  unsigned int D.44936;
  unsigned int D.44937;
  unsigned int D.44938;
  int D.44939;
  unsigned int D.44940;
  unsigned int D.44941;
  int D.44942;
  unsigned int D.44943;
  unsigned int D.44944;
  int D.44945;
  long int D.44946;
  struct MonoInst * D.44947;
  int D.44948;
  int D.44949;
  const unsigned char * D.44950;
  int D.44951;
  struct MonoBasicBlock * D.44952;
  struct MonoInst * D.44953;
  long int D.44957;
  struct MonoInst * D.44958;
  int D.44959;
  int D.44960;
  unsigned int D.44963;
  unsigned int D.44964;
  int D.44965;
  unsigned char * D.44969;
  struct MonoBasicBlock * * D.44972;
  long int D.44973;
  unsigned char * D.44974;
  long int D.44975;
  long int D.44976;
  long unsigned int D.44977;
  long unsigned int D.44978;
  struct MonoBasicBlock * * D.44979;
  unsigned int D.44980;
  short unsigned int D.44985;
  short unsigned int D.44986;
  short unsigned int D.44988;
  short unsigned int D.44990;
  struct MonoBasicBlock * * D.44991;
  struct MonoBasicBlock * * D.44992;
  struct MonoBasicBlock * D.44993;
  void * D.45003;
  struct MonoBasicBlock * * D.45004;
  struct MonoBasicBlock * * D.45005;
  long unsigned int D.45009;
  long unsigned int D.45010;
  unsigned int D.45013;
  unsigned int D.45014;
  int D.45015;
  long int D.45033;
  struct MonoInst * D.45034;
  int D.45035;
  int D.45036;
  long int D.45040;
  struct MonoInst * D.45041;
  int D.45042;
  int D.45043;
  unsigned int D.45046;
  unsigned int D.45047;
  int D.45048;
  unsigned char * D.45052;
  long int D.45055;
  long int D.45056;
  long unsigned int D.45057;
  long unsigned int D.45058;
  struct MonoBasicBlock * * D.45059;
  void * D.45075;
  struct MonoBasicBlock * * D.45076;
  struct MonoBasicBlock * * D.45077;
  unsigned int D.45083;
  unsigned int D.45084;
  int D.45085;
  unsigned int D.45103;
  long int D.45104;
  struct MonoInst * D.45105;
  int D.45106;
  int D.45107;
  int D.45108;
  long int D.45112;
  struct MonoInst * D.45113;
  int D.45114;
  int D.45115;
  unsigned int D.45118;
  unsigned int D.45119;
  int D.45120;
  unsigned char * D.45124;
  long int D.45127;
  long int D.45128;
  long unsigned int D.45129;
  long unsigned int D.45130;
  struct MonoBasicBlock * * D.45131;
  void * D.45147;
  struct MonoBasicBlock * * D.45148;
  struct MonoBasicBlock * * D.45149;
  unsigned int D.45155;
  unsigned int D.45156;
  int D.45157;
  unsigned char * D.45175;
  long int D.45178;
  long int D.45179;
  long unsigned int D.45180;
  long unsigned int D.45181;
  struct MonoBasicBlock * * D.45182;
  unsigned int D.45197;
  struct MonoInst * iftmp.382;
  unsigned int D.45199;
  unsigned int dreg.383;
  struct MonoInst * * D.45203;
  long unsigned int D.45204;
  long unsigned int D.45205;
  struct MonoInst * * D.45206;
  struct MonoType * D.45210;
  unsigned char D.45211;
  unsigned char D.45212;
  struct MonoClass * D.45213;
  unsigned int D.45214;
  int D.45215;
  int D.45216;
  _Bool D.45217;
  long int D.45218;
  long int D.45219;
  struct MonoType * D.45222;
  int D.45223;
  struct MonoInst * iftmp.384;
  int D.45229;
  int D.45230;
  unsigned int D.45231;
  sizetype D.45234;
  sizetype D.45235;
  sizetype D.45236;
  struct MonoInst * * D.45237;
  struct MonoInst * iftmp.385;
  int D.45240;
  unsigned int D.45241;
  sizetype D.45244;
  sizetype D.45245;
  struct MonoInst * * D.45246;
  _Bool D.45248;
  long int D.45249;
  long int D.45250;
  _Bool D.45253;
  long int D.45254;
  long int D.45255;
  unsigned char D.45258;
  unsigned char D.45259;
  unsigned char D.45260;
  unsigned char D.45261;
  long int D.45265;
  struct MonoInst * D.45266;
  int D.45267;
  int D.45268;
  int D.45269;
  long int D.45273;
  struct MonoInst * D.45274;
  int D.45275;
  int D.45276;
  unsigned int D.45279;
  unsigned int D.45280;
  int D.45281;
  unsigned char * D.45285;
  long int D.45288;
  long int D.45289;
  long unsigned int D.45290;
  long unsigned int D.45291;
  struct MonoBasicBlock * * D.45292;
  void * D.45308;
  struct MonoBasicBlock * * D.45309;
  struct MonoBasicBlock * * D.45310;
  unsigned int D.45316;
  unsigned int D.45317;
  int D.45318;
  unsigned char * D.45336;
  long int D.45339;
  long int D.45340;
  long unsigned int D.45341;
  long unsigned int D.45342;
  struct MonoBasicBlock * * D.45343;
  struct MonoClass * D.45358;
  struct MonoType * D.45359;
  struct MonoInst * iftmp.386;
  int D.45361;
  unsigned int D.45362;
  long unsigned int D.45365;
  long unsigned int D.45366;
  struct MonoInst * * D.45367;
  long int D.45371;
  struct MonoInst * D.45372;
  int D.45373;
  int D.45374;
  unsigned char D.45375;
  unsigned char D.45376;
  struct MonoClass * D.45377;
  unsigned int D.45378;
  int D.45379;
  struct MonoType * D.45382;
  int D.45383;
  struct MonoInst * iftmp.387;
  int D.45389;
  int D.45390;
  unsigned int D.45391;
  sizetype D.45394;
  sizetype D.45395;
  sizetype D.45396;
  struct MonoInst * * D.45397;
  struct MonoInst * iftmp.388;
  int D.45400;
  unsigned int D.45401;
  sizetype D.45404;
  sizetype D.45405;
  struct MonoInst * * D.45406;
  _Bool D.45408;
  long int D.45409;
  long int D.45410;
  _Bool D.45413;
  long int D.45414;
  long int D.45415;
  unsigned char D.45418;
  unsigned char D.45419;
  unsigned char D.45420;
  unsigned char D.45421;
  long int D.45425;
  struct MonoInst * D.45426;
  int D.45427;
  int D.45428;
  unsigned int D.45431;
  unsigned int D.45432;
  int D.45433;
  unsigned char * D.45437;
  long int D.45440;
  long int D.45441;
  long unsigned int D.45442;
  long unsigned int D.45443;
  struct MonoBasicBlock * * D.45444;
  void * D.45460;
  struct MonoBasicBlock * * D.45461;
  struct MonoBasicBlock * * D.45462;
  unsigned int D.45468;
  unsigned int D.45469;
  int D.45470;
  unsigned char * D.45488;
  long int D.45491;
  long int D.45492;
  long unsigned int D.45493;
  long unsigned int D.45494;
  struct MonoBasicBlock * * D.45495;
  long int D.45510;
  struct MonoInst * D.45511;
  unsigned int D.45512;
  short unsigned int D.45513;
  int D.45514;
  int D.45515;
  unsigned char D.45516;
  <unnamed type> D.45517;
  unsigned int D.45518;
  int D.45519;
  struct MonoInst * D.45523;
  struct MonoInst * addr;
  struct MonoInst * klass_inst;
  struct MonoInst * is_ref;
  struct MonoInst * args[16];
  struct MonoBasicBlock * is_ref_bb;
  struct MonoBasicBlock * is_nullable_bb;
  struct MonoBasicBlock * end_bb;
  struct MonoInst * ins;
  int dreg;
  int addr_reg;

  try
    {
      klass_inst = emit_get_gsharedvt_info_klass (cfg, klass, 1);
      obj.380 = obj;
      args[0] = obj.380;
      args[1] = klass_inst;
      obj.381 = mono_emit_jit_icall (cfg, mono_object_castclass_unbox, &args);
      obj = obj.381;
      D.44935 = cfg->mempool;
      is_ref_bb = mono_mempool_alloc0 (D.44935, 296);
      D.44936 = cfg->num_bblocks;
      D.44937 = D.44936;
      D.44938 = D.44937 + 1;
      cfg->num_bblocks = D.44938;
      D.44939 = (int) D.44937;
      is_ref_bb->block_num = D.44939;
      D.44935 = cfg->mempool;
      is_nullable_bb = mono_mempool_alloc0 (D.44935, 296);
      D.44936 = cfg->num_bblocks;
      D.44940 = D.44936;
      D.44941 = D.44940 + 1;
      cfg->num_bblocks = D.44941;
      D.44942 = (int) D.44940;
      is_nullable_bb->block_num = D.44942;
      D.44935 = cfg->mempool;
      end_bb = mono_mempool_alloc0 (D.44935, 296);
      D.44936 = cfg->num_bblocks;
      D.44943 = D.44936;
      D.44944 = D.44943 + 1;
      cfg->num_bblocks = D.44944;
      D.44945 = (int) D.44943;
      end_bb->block_num = D.44945;
      is_ref = emit_get_gsharedvt_info_klass (cfg, klass, 19);
      {
        struct MonoInst * inst;

        D.44935 = cfg->mempool;
        inst = mono_mempool_alloc (D.44935, 80);
        inst->data.op[1].const_val = 0;
        D.44946 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.44946;
        inst->prev = 0B;
        D.44947 = inst->prev;
        inst->next = D.44947;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.44948 = inst->sreg3;
        inst->sreg2 = D.44948;
        D.44949 = inst->sreg2;
        inst->sreg1 = D.44949;
        D.44950 = cfg->ip;
        inst->cil_code = D.44950;
        inst->dreg = -1;
        D.44951 = is_ref->dreg;
        inst->sreg1 = D.44951;
        inst->data.op[1].const_val = 1;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.44954>; else goto <D.44955>;
        <D.44954>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44953->next = inst;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        inst->prev = D.44953;
        D.44952 = cfg->cbb;
        D.44952->last_ins = inst;
        goto <D.44956>;
        <D.44955>:
        D.44952 = cfg->cbb;
        D.44952 = cfg->cbb;
        D.44952->last_ins = inst;
        D.44953 = D.44952->last_ins;
        D.44952->code = D.44953;
        <D.44956>:
      }
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.44935 = cfg->mempool;
        ins = mono_mempool_alloc (D.44935, 80);
        ins->data.op[1].const_val = 0;
        D.44957 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.44957;
        ins->prev = 0B;
        D.44958 = ins->prev;
        ins->next = D.44958;
        ins->opcode = 648;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.44959 = ins->sreg3;
        ins->sreg2 = D.44959;
        D.44960 = ins->sreg2;
        ins->sreg1 = D.44960;
        D.44950 = cfg->ip;
        ins->cil_code = D.44950;
        if (0 != 0) goto <D.44961>; else goto <D.44962>;
        <D.44961>:
        D.44935 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.44935, 296);
        D.44936 = cfg->num_bblocks;
        D.44963 = D.44936;
        D.44964 = D.44963 + 1;
        cfg->num_bblocks = D.44964;
        D.44965 = (int) D.44963;
        falsebb->block_num = D.44965;
        ins->data.op[0].target_block = is_ref_bb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, is_ref_bb);
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.44966>; else goto <D.44967>;
        <D.44966>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44953->next = ins;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        ins->prev = D.44953;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        goto <D.44968>;
        <D.44967>:
        D.44952 = cfg->cbb;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        D.44953 = D.44952->last_ins;
        D.44952->code = D.44953;
        <D.44968>:
        D.44969 = falsebb->cil_code;
        if (D.44969 != 0B) goto <D.44970>; else goto <D.44971>;
        <D.44970>:
        D.44972 = cfg->cil_offset_to_bb;
        D.44969 = falsebb->cil_code;
        D.44973 = (long int) D.44969;
        D.44974 = cfg->cil_start;
        D.44975 = (long int) D.44974;
        D.44976 = D.44973 - D.44975;
        D.44977 = (long unsigned int) D.44976;
        D.44978 = D.44977 * 8;
        D.44979 = D.44972 + D.44978;
        *D.44979 = falsebb;
        <D.44971>:
        D.44980 = cfg->real_offset;
        falsebb->real_offset = D.44980;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.44984>; else goto <D.44981>;
        <D.44984>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 <= 9) goto <D.44982>; else goto <D.44987>;
        <D.44987>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 <= 9) goto <D.44982>; else goto <D.44989>;
        <D.44989>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 <= 9) goto <D.44982>; else goto <D.44981>;
        <D.44982>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        D.44993 = *D.44992;
        if (D.44993 == 0B) goto <D.44994>; else goto <D.44981>;
        <D.44994>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        *D.44992 = falsebb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        goto <D.44983>;
        <D.44981>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 == 0B) goto <D.44995>; else goto <D.44997>;
        <D.44997>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 442) goto <D.44998>; else goto <D.44996>;
        <D.44998>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 759) goto <D.44999>; else goto <D.44996>;
        <D.44999>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 > 9) goto <D.45000>; else goto <D.44996>;
        <D.45000>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 > 9) goto <D.45001>; else goto <D.44996>;
        <D.45001>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 > 9) goto <D.44995>; else goto <D.44996>;
        <D.44995>:
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        <D.44996>:
        <D.44983>:
        D.44952 = cfg->cbb;
        D.44952->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.45002>;
        <D.44962>:
        D.44935 = cfg->mempool;
        D.45003 = mono_mempool_alloc (D.44935, 16);
        ins->data.op[1].many_blocks = D.45003;
        D.45004 = ins->data.op[1].many_blocks;
        *D.45004 = is_ref_bb;
        D.45004 = ins->data.op[1].many_blocks;
        D.45005 = D.45004 + 8;
        *D.45005 = 0B;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, is_ref_bb);
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45006>; else goto <D.45007>;
        <D.45006>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44953->next = ins;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        ins->prev = D.44953;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        goto <D.45008>;
        <D.45007>:
        D.44952 = cfg->cbb;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        D.44953 = D.44952->last_ins;
        D.44952->code = D.44953;
        <D.45008>:
        D.45009 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.45010 = D.45009 & 268435456;
        if (D.45010 == 0) goto <D.45011>; else goto <D.45012>;
        <D.45011>:
        D.44935 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.44935, 296);
        D.44936 = cfg->num_bblocks;
        D.45013 = D.44936;
        D.45014 = D.45013 + 1;
        cfg->num_bblocks = D.45014;
        D.45015 = (int) D.45013;
        falsebb->block_num = D.45015;
        D.45004 = ins->data.op[1].many_blocks;
        D.45005 = D.45004 + 8;
        *D.45005 = falsebb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        D.44969 = falsebb->cil_code;
        if (D.44969 != 0B) goto <D.45016>; else goto <D.45017>;
        <D.45016>:
        D.44972 = cfg->cil_offset_to_bb;
        D.44969 = falsebb->cil_code;
        D.44973 = (long int) D.44969;
        D.44974 = cfg->cil_start;
        D.44975 = (long int) D.44974;
        D.44976 = D.44973 - D.44975;
        D.44977 = (long unsigned int) D.44976;
        D.44978 = D.44977 * 8;
        D.44979 = D.44972 + D.44978;
        *D.44979 = falsebb;
        <D.45017>:
        D.44980 = cfg->real_offset;
        falsebb->real_offset = D.44980;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45021>; else goto <D.45018>;
        <D.45021>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 <= 9) goto <D.45019>; else goto <D.45022>;
        <D.45022>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 <= 9) goto <D.45019>; else goto <D.45023>;
        <D.45023>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 <= 9) goto <D.45019>; else goto <D.45018>;
        <D.45019>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        D.44993 = *D.44992;
        if (D.44993 == 0B) goto <D.45024>; else goto <D.45018>;
        <D.45024>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        *D.44992 = falsebb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        goto <D.45020>;
        <D.45018>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 == 0B) goto <D.45025>; else goto <D.45027>;
        <D.45027>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 442) goto <D.45028>; else goto <D.45026>;
        <D.45028>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 759) goto <D.45029>; else goto <D.45026>;
        <D.45029>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 > 9) goto <D.45030>; else goto <D.45026>;
        <D.45030>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 > 9) goto <D.45031>; else goto <D.45026>;
        <D.45031>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 > 9) goto <D.45025>; else goto <D.45026>;
        <D.45025>:
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        <D.45026>:
        <D.45020>:
        D.44952 = cfg->cbb;
        D.44952->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.45032>;
        <D.45012>:
        D.44952 = cfg->cbb;
        D.44952->extended = 1;
        <D.45032>:
        <D.45002>:
      }
      {
        struct MonoInst * inst;

        D.44935 = cfg->mempool;
        inst = mono_mempool_alloc (D.44935, 80);
        inst->data.op[1].const_val = 0;
        D.45033 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.45033;
        inst->prev = 0B;
        D.45034 = inst->prev;
        inst->next = D.45034;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.45035 = inst->sreg3;
        inst->sreg2 = D.45035;
        D.45036 = inst->sreg2;
        inst->sreg1 = D.45036;
        D.44950 = cfg->ip;
        inst->cil_code = D.44950;
        inst->dreg = -1;
        D.44951 = is_ref->dreg;
        inst->sreg1 = D.44951;
        inst->data.op[1].const_val = 2;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45037>; else goto <D.45038>;
        <D.45037>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44953->next = inst;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        inst->prev = D.44953;
        D.44952 = cfg->cbb;
        D.44952->last_ins = inst;
        goto <D.45039>;
        <D.45038>:
        D.44952 = cfg->cbb;
        D.44952 = cfg->cbb;
        D.44952->last_ins = inst;
        D.44953 = D.44952->last_ins;
        D.44952->code = D.44953;
        <D.45039>:
      }
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.44935 = cfg->mempool;
        ins = mono_mempool_alloc (D.44935, 80);
        ins->data.op[1].const_val = 0;
        D.45040 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.45040;
        ins->prev = 0B;
        D.45041 = ins->prev;
        ins->next = D.45041;
        ins->opcode = 648;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.45042 = ins->sreg3;
        ins->sreg2 = D.45042;
        D.45043 = ins->sreg2;
        ins->sreg1 = D.45043;
        D.44950 = cfg->ip;
        ins->cil_code = D.44950;
        if (0 != 0) goto <D.45044>; else goto <D.45045>;
        <D.45044>:
        D.44935 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.44935, 296);
        D.44936 = cfg->num_bblocks;
        D.45046 = D.44936;
        D.45047 = D.45046 + 1;
        cfg->num_bblocks = D.45047;
        D.45048 = (int) D.45046;
        falsebb->block_num = D.45048;
        ins->data.op[0].target_block = is_nullable_bb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, is_nullable_bb);
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45049>; else goto <D.45050>;
        <D.45049>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44953->next = ins;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        ins->prev = D.44953;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        goto <D.45051>;
        <D.45050>:
        D.44952 = cfg->cbb;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        D.44953 = D.44952->last_ins;
        D.44952->code = D.44953;
        <D.45051>:
        D.45052 = falsebb->cil_code;
        if (D.45052 != 0B) goto <D.45053>; else goto <D.45054>;
        <D.45053>:
        D.44972 = cfg->cil_offset_to_bb;
        D.45052 = falsebb->cil_code;
        D.45055 = (long int) D.45052;
        D.44974 = cfg->cil_start;
        D.44975 = (long int) D.44974;
        D.45056 = D.45055 - D.44975;
        D.45057 = (long unsigned int) D.45056;
        D.45058 = D.45057 * 8;
        D.45059 = D.44972 + D.45058;
        *D.45059 = falsebb;
        <D.45054>:
        D.44980 = cfg->real_offset;
        falsebb->real_offset = D.44980;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45063>; else goto <D.45060>;
        <D.45063>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 <= 9) goto <D.45061>; else goto <D.45064>;
        <D.45064>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 <= 9) goto <D.45061>; else goto <D.45065>;
        <D.45065>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 <= 9) goto <D.45061>; else goto <D.45060>;
        <D.45061>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        D.44993 = *D.44992;
        if (D.44993 == 0B) goto <D.45066>; else goto <D.45060>;
        <D.45066>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        *D.44992 = falsebb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        goto <D.45062>;
        <D.45060>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 == 0B) goto <D.45067>; else goto <D.45069>;
        <D.45069>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 442) goto <D.45070>; else goto <D.45068>;
        <D.45070>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 759) goto <D.45071>; else goto <D.45068>;
        <D.45071>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 > 9) goto <D.45072>; else goto <D.45068>;
        <D.45072>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 > 9) goto <D.45073>; else goto <D.45068>;
        <D.45073>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 > 9) goto <D.45067>; else goto <D.45068>;
        <D.45067>:
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        <D.45068>:
        <D.45062>:
        D.44952 = cfg->cbb;
        D.44952->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.45074>;
        <D.45045>:
        D.44935 = cfg->mempool;
        D.45075 = mono_mempool_alloc (D.44935, 16);
        ins->data.op[1].many_blocks = D.45075;
        D.45076 = ins->data.op[1].many_blocks;
        *D.45076 = is_nullable_bb;
        D.45076 = ins->data.op[1].many_blocks;
        D.45077 = D.45076 + 8;
        *D.45077 = 0B;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, is_nullable_bb);
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45078>; else goto <D.45079>;
        <D.45078>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44953->next = ins;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        ins->prev = D.44953;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        goto <D.45080>;
        <D.45079>:
        D.44952 = cfg->cbb;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        D.44953 = D.44952->last_ins;
        D.44952->code = D.44953;
        <D.45080>:
        D.45009 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.45010 = D.45009 & 268435456;
        if (D.45010 == 0) goto <D.45081>; else goto <D.45082>;
        <D.45081>:
        D.44935 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.44935, 296);
        D.44936 = cfg->num_bblocks;
        D.45083 = D.44936;
        D.45084 = D.45083 + 1;
        cfg->num_bblocks = D.45084;
        D.45085 = (int) D.45083;
        falsebb->block_num = D.45085;
        D.45076 = ins->data.op[1].many_blocks;
        D.45077 = D.45076 + 8;
        *D.45077 = falsebb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        D.45052 = falsebb->cil_code;
        if (D.45052 != 0B) goto <D.45086>; else goto <D.45087>;
        <D.45086>:
        D.44972 = cfg->cil_offset_to_bb;
        D.45052 = falsebb->cil_code;
        D.45055 = (long int) D.45052;
        D.44974 = cfg->cil_start;
        D.44975 = (long int) D.44974;
        D.45056 = D.45055 - D.44975;
        D.45057 = (long unsigned int) D.45056;
        D.45058 = D.45057 * 8;
        D.45059 = D.44972 + D.45058;
        *D.45059 = falsebb;
        <D.45087>:
        D.44980 = cfg->real_offset;
        falsebb->real_offset = D.44980;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45091>; else goto <D.45088>;
        <D.45091>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 <= 9) goto <D.45089>; else goto <D.45092>;
        <D.45092>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 <= 9) goto <D.45089>; else goto <D.45093>;
        <D.45093>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 <= 9) goto <D.45089>; else goto <D.45088>;
        <D.45089>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        D.44993 = *D.44992;
        if (D.44993 == 0B) goto <D.45094>; else goto <D.45088>;
        <D.45094>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        *D.44992 = falsebb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        goto <D.45090>;
        <D.45088>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 == 0B) goto <D.45095>; else goto <D.45097>;
        <D.45097>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 442) goto <D.45098>; else goto <D.45096>;
        <D.45098>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 759) goto <D.45099>; else goto <D.45096>;
        <D.45099>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 > 9) goto <D.45100>; else goto <D.45096>;
        <D.45100>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 > 9) goto <D.45101>; else goto <D.45096>;
        <D.45101>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 > 9) goto <D.45095>; else goto <D.45096>;
        <D.45095>:
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        <D.45096>:
        <D.45090>:
        D.44952 = cfg->cbb;
        D.44952->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.45102>;
        <D.45082>:
        D.44952 = cfg->cbb;
        D.44952->extended = 1;
        <D.45102>:
        <D.45074>:
      }
      D.45103 = alloc_dreg (cfg, 5);
      addr_reg = (int) D.45103;
      D.44935 = cfg->mempool;
      addr = mono_mempool_alloc (D.44935, 80);
      addr->data.op[1].const_val = 0;
      D.45104 = addr->data.op[1].const_val;
      addr->data.op[0].const_val = D.45104;
      addr->prev = 0B;
      D.45105 = addr->prev;
      addr->next = D.45105;
      addr->opcode = 429;
      addr->flags = 0;
      addr->type = 0;
      addr->dreg = -1;
      addr->sreg3 = -1;
      D.45106 = addr->sreg3;
      addr->sreg2 = D.45106;
      D.45107 = addr->sreg2;
      addr->sreg1 = D.45107;
      D.44950 = cfg->ip;
      addr->cil_code = D.44950;
      addr->dreg = addr_reg;
      obj.380 = obj;
      D.45108 = obj.380->dreg;
      addr->sreg1 = D.45108;
      addr->data.op[1].const_val = 16;
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      if (D.44953 != 0B) goto <D.45109>; else goto <D.45110>;
      <D.45109>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44953->next = addr;
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      addr->prev = D.44953;
      D.44952 = cfg->cbb;
      D.44952->last_ins = addr;
      goto <D.45111>;
      <D.45110>:
      D.44952 = cfg->cbb;
      D.44952 = cfg->cbb;
      D.44952->last_ins = addr;
      D.44953 = D.44952->last_ins;
      D.44952->code = D.44953;
      <D.45111>:
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.44935 = cfg->mempool;
        ins = mono_mempool_alloc (D.44935, 80);
        ins->data.op[1].const_val = 0;
        D.45112 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.45112;
        ins->prev = 0B;
        D.45113 = ins->prev;
        ins->next = D.45113;
        ins->opcode = 442;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.45114 = ins->sreg3;
        ins->sreg2 = D.45114;
        D.45115 = ins->sreg2;
        ins->sreg1 = D.45115;
        D.44950 = cfg->ip;
        ins->cil_code = D.44950;
        if (1 != 0) goto <D.45116>; else goto <D.45117>;
        <D.45116>:
        D.44935 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.44935, 296);
        D.44936 = cfg->num_bblocks;
        D.45118 = D.44936;
        D.45119 = D.45118 + 1;
        cfg->num_bblocks = D.45119;
        D.45120 = (int) D.45118;
        falsebb->block_num = D.45120;
        ins->data.op[0].target_block = end_bb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, end_bb);
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45121>; else goto <D.45122>;
        <D.45121>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44953->next = ins;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        ins->prev = D.44953;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        goto <D.45123>;
        <D.45122>:
        D.44952 = cfg->cbb;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        D.44953 = D.44952->last_ins;
        D.44952->code = D.44953;
        <D.45123>:
        D.45124 = falsebb->cil_code;
        if (D.45124 != 0B) goto <D.45125>; else goto <D.45126>;
        <D.45125>:
        D.44972 = cfg->cil_offset_to_bb;
        D.45124 = falsebb->cil_code;
        D.45127 = (long int) D.45124;
        D.44974 = cfg->cil_start;
        D.44975 = (long int) D.44974;
        D.45128 = D.45127 - D.44975;
        D.45129 = (long unsigned int) D.45128;
        D.45130 = D.45129 * 8;
        D.45131 = D.44972 + D.45130;
        *D.45131 = falsebb;
        <D.45126>:
        D.44980 = cfg->real_offset;
        falsebb->real_offset = D.44980;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45135>; else goto <D.45132>;
        <D.45135>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 <= 9) goto <D.45133>; else goto <D.45136>;
        <D.45136>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 <= 9) goto <D.45133>; else goto <D.45137>;
        <D.45137>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 <= 9) goto <D.45133>; else goto <D.45132>;
        <D.45133>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        D.44993 = *D.44992;
        if (D.44993 == 0B) goto <D.45138>; else goto <D.45132>;
        <D.45138>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        *D.44992 = falsebb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        goto <D.45134>;
        <D.45132>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 == 0B) goto <D.45139>; else goto <D.45141>;
        <D.45141>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 442) goto <D.45142>; else goto <D.45140>;
        <D.45142>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 759) goto <D.45143>; else goto <D.45140>;
        <D.45143>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 > 9) goto <D.45144>; else goto <D.45140>;
        <D.45144>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 > 9) goto <D.45145>; else goto <D.45140>;
        <D.45145>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 > 9) goto <D.45139>; else goto <D.45140>;
        <D.45139>:
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        <D.45140>:
        <D.45134>:
        D.44952 = cfg->cbb;
        D.44952->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.45146>;
        <D.45117>:
        D.44935 = cfg->mempool;
        D.45147 = mono_mempool_alloc (D.44935, 16);
        ins->data.op[1].many_blocks = D.45147;
        D.45148 = ins->data.op[1].many_blocks;
        *D.45148 = end_bb;
        D.45148 = ins->data.op[1].many_blocks;
        D.45149 = D.45148 + 8;
        *D.45149 = 0B;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, end_bb);
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45150>; else goto <D.45151>;
        <D.45150>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44953->next = ins;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        ins->prev = D.44953;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        goto <D.45152>;
        <D.45151>:
        D.44952 = cfg->cbb;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        D.44953 = D.44952->last_ins;
        D.44952->code = D.44953;
        <D.45152>:
        D.45009 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.45010 = D.45009 & 268435456;
        if (D.45010 == 0) goto <D.45153>; else goto <D.45154>;
        <D.45153>:
        D.44935 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.44935, 296);
        D.44936 = cfg->num_bblocks;
        D.45155 = D.44936;
        D.45156 = D.45155 + 1;
        cfg->num_bblocks = D.45156;
        D.45157 = (int) D.45155;
        falsebb->block_num = D.45157;
        D.45148 = ins->data.op[1].many_blocks;
        D.45149 = D.45148 + 8;
        *D.45149 = falsebb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        D.45124 = falsebb->cil_code;
        if (D.45124 != 0B) goto <D.45158>; else goto <D.45159>;
        <D.45158>:
        D.44972 = cfg->cil_offset_to_bb;
        D.45124 = falsebb->cil_code;
        D.45127 = (long int) D.45124;
        D.44974 = cfg->cil_start;
        D.44975 = (long int) D.44974;
        D.45128 = D.45127 - D.44975;
        D.45129 = (long unsigned int) D.45128;
        D.45130 = D.45129 * 8;
        D.45131 = D.44972 + D.45130;
        *D.45131 = falsebb;
        <D.45159>:
        D.44980 = cfg->real_offset;
        falsebb->real_offset = D.44980;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45163>; else goto <D.45160>;
        <D.45163>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 <= 9) goto <D.45161>; else goto <D.45164>;
        <D.45164>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 <= 9) goto <D.45161>; else goto <D.45165>;
        <D.45165>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 <= 9) goto <D.45161>; else goto <D.45160>;
        <D.45161>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        D.44993 = *D.44992;
        if (D.44993 == 0B) goto <D.45166>; else goto <D.45160>;
        <D.45166>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        *D.44992 = falsebb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        goto <D.45162>;
        <D.45160>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 == 0B) goto <D.45167>; else goto <D.45169>;
        <D.45169>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 442) goto <D.45170>; else goto <D.45168>;
        <D.45170>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 759) goto <D.45171>; else goto <D.45168>;
        <D.45171>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 > 9) goto <D.45172>; else goto <D.45168>;
        <D.45172>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 > 9) goto <D.45173>; else goto <D.45168>;
        <D.45173>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 > 9) goto <D.45167>; else goto <D.45168>;
        <D.45167>:
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        <D.45168>:
        <D.45162>:
        D.44952 = cfg->cbb;
        D.44952->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.45174>;
        <D.45154>:
        D.44952 = cfg->cbb;
        D.44952->extended = 1;
        <D.45174>:
        <D.45146>:
      }
      D.45175 = is_ref_bb->cil_code;
      if (D.45175 != 0B) goto <D.45176>; else goto <D.45177>;
      <D.45176>:
      D.44972 = cfg->cil_offset_to_bb;
      D.45175 = is_ref_bb->cil_code;
      D.45178 = (long int) D.45175;
      D.44974 = cfg->cil_start;
      D.44975 = (long int) D.44974;
      D.45179 = D.45178 - D.44975;
      D.45180 = (long unsigned int) D.45179;
      D.45181 = D.45180 * 8;
      D.45182 = D.44972 + D.45181;
      *D.45182 = is_ref_bb;
      <D.45177>:
      D.44980 = cfg->real_offset;
      is_ref_bb->real_offset = D.44980;
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      if (D.44953 != 0B) goto <D.45186>; else goto <D.45183>;
      <D.45186>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      D.44986 = D.44985 + 64985;
      if (D.44986 <= 9) goto <D.45184>; else goto <D.45187>;
      <D.45187>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      D.44988 = D.44985 + 64878;
      if (D.44988 <= 9) goto <D.45184>; else goto <D.45188>;
      <D.45188>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      D.44990 = D.44985 + 64888;
      if (D.44990 <= 9) goto <D.45184>; else goto <D.45183>;
      <D.45184>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44991 = D.44953->data.op[1].many_blocks;
      D.44992 = D.44991 + 8;
      D.44993 = *D.44992;
      if (D.44993 == 0B) goto <D.45189>; else goto <D.45183>;
      <D.45189>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44991 = D.44953->data.op[1].many_blocks;
      D.44992 = D.44991 + 8;
      *D.44992 = is_ref_bb;
      D.44952 = cfg->cbb;
      mono_link_bblock (cfg, D.44952, is_ref_bb);
      goto <D.45185>;
      <D.45183>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      if (D.44953 == 0B) goto <D.45190>; else goto <D.45192>;
      <D.45192>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      if (D.44985 != 442) goto <D.45193>; else goto <D.45191>;
      <D.45193>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      if (D.44985 != 759) goto <D.45194>; else goto <D.45191>;
      <D.45194>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      D.44986 = D.44985 + 64985;
      if (D.44986 > 9) goto <D.45195>; else goto <D.45191>;
      <D.45195>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      D.44988 = D.44985 + 64878;
      if (D.44988 > 9) goto <D.45196>; else goto <D.45191>;
      <D.45196>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      D.44990 = D.44985 + 64888;
      if (D.44990 > 9) goto <D.45190>; else goto <D.45191>;
      <D.45190>:
      D.44952 = cfg->cbb;
      mono_link_bblock (cfg, D.44952, is_ref_bb);
      <D.45191>:
      <D.45185>:
      D.44952 = cfg->cbb;
      D.44952->next_bb = is_ref_bb;
      cfg->cbb = is_ref_bb;
      D.45197 = alloc_ireg (cfg);
      dreg = (int) D.45197;
      {
        struct MonoInst * var;

        D.45199 = cfg->vreg_to_inst_len;
        dreg.383 = (unsigned int) dreg;
        if (D.45199 > dreg.383) goto <D.45201>; else goto <D.45202>;
        <D.45201>:
        D.45203 = cfg->vreg_to_inst;
        D.45204 = (long unsigned int) dreg;
        D.45205 = D.45204 * 8;
        D.45206 = D.45203 + D.45205;
        iftmp.382 = *D.45206;
        goto <D.45207>;
        <D.45202>:
        iftmp.382 = 0B;
        <D.45207>:
        var = iftmp.382;
        if (var == 0B) goto <D.45208>; else goto <D.45209>;
        <D.45208>:
        D.45210 = &klass->byval_arg;
        var = mono_compile_create_var_for_vreg (cfg, D.45210, 329, dreg);
        <D.45209>:
        D.44935 = cfg->mempool;
        addr = mono_mempool_alloc (D.44935, 80);
        addr->data.op[1].const_val = 0;
        D.45104 = addr->data.op[1].const_val;
        addr->data.op[0].const_val = D.45104;
        addr->prev = 0B;
        D.45105 = addr->prev;
        addr->next = D.45105;
        addr->opcode = 314;
        addr->flags = 0;
        addr->type = 0;
        addr->dreg = -1;
        addr->sreg3 = -1;
        D.45106 = addr->sreg3;
        addr->sreg2 = D.45106;
        D.45107 = addr->sreg2;
        addr->sreg1 = D.45107;
        D.44950 = cfg->ip;
        addr->cil_code = D.44950;
        addr->data.op[0].p = var;
        D.45211 = var->flags;
        D.45212 = D.45211 | 16;
        var->flags = D.45212;
        addr->type = 5;
        D.45213 = var->klass;
        addr->klass = D.45213;
        D.45214 = alloc_dreg (cfg, 5);
        D.45215 = (int) D.45214;
        addr->dreg = D.45215;
        cfg->has_indirection = 1;
        D.45216 = cfg->gsharedvt;
        D.45217 = D.45216 != 0;
        D.45218 = (long int) D.45217;
        D.45219 = __builtin_expect (D.45218, 0);
        if (D.45219 != 0) goto <D.45220>; else goto <D.45221>;
        <D.45220>:
        D.45222 = var->data.op[1].vtype;
        D.45223 = mini_is_gsharedvt_variable_type (cfg, D.45222);
        if (D.45223 != 0) goto <D.45224>; else goto <D.45225>;
        <D.45224>:
        handle_gsharedvt_ldaddr (cfg);
        <D.45225>:
        <D.45221>:
        if (0 != 0) goto <D.45226>; else goto <D.45227>;
        <D.45226>:
        {
          struct MonoInst * var1;
          struct MonoInst * var2;

          D.45229 = var->dreg;
          D.45230 = D.45229 + 1;
          D.45231 = (unsigned int) D.45230;
          D.45199 = cfg->vreg_to_inst_len;
          if (D.45231 < D.45199) goto <D.45232>; else goto <D.45233>;
          <D.45232>:
          D.45203 = cfg->vreg_to_inst;
          D.45229 = var->dreg;
          D.45234 = (sizetype) D.45229;
          D.45235 = D.45234 + 1;
          D.45236 = D.45235 * 8;
          D.45237 = D.45203 + D.45236;
          iftmp.384 = *D.45237;
          goto <D.45238>;
          <D.45233>:
          iftmp.384 = 0B;
          <D.45238>:
          var1 = iftmp.384;
          D.45229 = var->dreg;
          D.45240 = D.45229 + 2;
          D.45241 = (unsigned int) D.45240;
          D.45199 = cfg->vreg_to_inst_len;
          if (D.45241 < D.45199) goto <D.45242>; else goto <D.45243>;
          <D.45242>:
          D.45203 = cfg->vreg_to_inst;
          D.45229 = var->dreg;
          D.45234 = (sizetype) D.45229;
          D.45244 = D.45234 + 2;
          D.45245 = D.45244 * 8;
          D.45246 = D.45203 + D.45245;
          iftmp.385 = *D.45246;
          goto <D.45247>;
          <D.45243>:
          iftmp.385 = 0B;
          <D.45247>:
          var2 = iftmp.385;
          D.45248 = var1 == 0B;
          D.45249 = (long int) D.45248;
          D.45250 = __builtin_expect (D.45249, 0);
          if (D.45250 != 0) goto <D.45251>; else goto <D.45252>;
          <D.45251>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3684, "var1");
          <D.45252>:
          D.45253 = var2 == 0B;
          D.45254 = (long int) D.45253;
          D.45255 = __builtin_expect (D.45254, 0);
          if (D.45255 != 0) goto <D.45256>; else goto <D.45257>;
          <D.45256>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3684, "var2");
          <D.45257>:
          D.45258 = var1->flags;
          D.45259 = D.45258 | 16;
          var1->flags = D.45259;
          D.45260 = var2->flags;
          D.45261 = D.45260 | 16;
          var2->flags = D.45261;
        }
        <D.45227>:
      }
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      if (D.44953 != 0B) goto <D.45262>; else goto <D.45263>;
      <D.45262>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44953->next = addr;
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      addr->prev = D.44953;
      D.44952 = cfg->cbb;
      D.44952->last_ins = addr;
      goto <D.45264>;
      <D.45263>:
      D.44952 = cfg->cbb;
      D.44952 = cfg->cbb;
      D.44952->last_ins = addr;
      D.44953 = D.44952->last_ins;
      D.44952->code = D.44953;
      <D.45264>:
      addr->dreg = addr_reg;
      {
        struct MonoInst * inst;

        D.44935 = cfg->mempool;
        inst = mono_mempool_alloc (D.44935, 80);
        inst->data.op[1].const_val = 0;
        D.45265 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.45265;
        inst->prev = 0B;
        D.45266 = inst->prev;
        inst->next = D.45266;
        inst->opcode = 374;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.45267 = inst->sreg3;
        inst->sreg2 = D.45267;
        D.45268 = inst->sreg2;
        inst->sreg1 = D.45268;
        D.44950 = cfg->ip;
        inst->cil_code = D.44950;
        obj.380 = obj;
        D.45108 = obj.380->dreg;
        inst->sreg1 = D.45108;
        D.45269 = addr->dreg;
        inst->dreg = D.45269;
        inst->data.op[0].const_val = 0;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45270>; else goto <D.45271>;
        <D.45270>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44953->next = inst;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        inst->prev = D.44953;
        D.44952 = cfg->cbb;
        D.44952->last_ins = inst;
        goto <D.45272>;
        <D.45271>:
        D.44952 = cfg->cbb;
        D.44952 = cfg->cbb;
        D.44952->last_ins = inst;
        D.44953 = D.44952->last_ins;
        D.44952->code = D.44953;
        <D.45272>:
      }
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.44935 = cfg->mempool;
        ins = mono_mempool_alloc (D.44935, 80);
        ins->data.op[1].const_val = 0;
        D.45273 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.45273;
        ins->prev = 0B;
        D.45274 = ins->prev;
        ins->next = D.45274;
        ins->opcode = 442;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.45275 = ins->sreg3;
        ins->sreg2 = D.45275;
        D.45276 = ins->sreg2;
        ins->sreg1 = D.45276;
        D.44950 = cfg->ip;
        ins->cil_code = D.44950;
        if (1 != 0) goto <D.45277>; else goto <D.45278>;
        <D.45277>:
        D.44935 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.44935, 296);
        D.44936 = cfg->num_bblocks;
        D.45279 = D.44936;
        D.45280 = D.45279 + 1;
        cfg->num_bblocks = D.45280;
        D.45281 = (int) D.45279;
        falsebb->block_num = D.45281;
        ins->data.op[0].target_block = end_bb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, end_bb);
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45282>; else goto <D.45283>;
        <D.45282>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44953->next = ins;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        ins->prev = D.44953;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        goto <D.45284>;
        <D.45283>:
        D.44952 = cfg->cbb;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        D.44953 = D.44952->last_ins;
        D.44952->code = D.44953;
        <D.45284>:
        D.45285 = falsebb->cil_code;
        if (D.45285 != 0B) goto <D.45286>; else goto <D.45287>;
        <D.45286>:
        D.44972 = cfg->cil_offset_to_bb;
        D.45285 = falsebb->cil_code;
        D.45288 = (long int) D.45285;
        D.44974 = cfg->cil_start;
        D.44975 = (long int) D.44974;
        D.45289 = D.45288 - D.44975;
        D.45290 = (long unsigned int) D.45289;
        D.45291 = D.45290 * 8;
        D.45292 = D.44972 + D.45291;
        *D.45292 = falsebb;
        <D.45287>:
        D.44980 = cfg->real_offset;
        falsebb->real_offset = D.44980;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45296>; else goto <D.45293>;
        <D.45296>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 <= 9) goto <D.45294>; else goto <D.45297>;
        <D.45297>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 <= 9) goto <D.45294>; else goto <D.45298>;
        <D.45298>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 <= 9) goto <D.45294>; else goto <D.45293>;
        <D.45294>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        D.44993 = *D.44992;
        if (D.44993 == 0B) goto <D.45299>; else goto <D.45293>;
        <D.45299>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        *D.44992 = falsebb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        goto <D.45295>;
        <D.45293>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 == 0B) goto <D.45300>; else goto <D.45302>;
        <D.45302>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 442) goto <D.45303>; else goto <D.45301>;
        <D.45303>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 759) goto <D.45304>; else goto <D.45301>;
        <D.45304>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 > 9) goto <D.45305>; else goto <D.45301>;
        <D.45305>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 > 9) goto <D.45306>; else goto <D.45301>;
        <D.45306>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 > 9) goto <D.45300>; else goto <D.45301>;
        <D.45300>:
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        <D.45301>:
        <D.45295>:
        D.44952 = cfg->cbb;
        D.44952->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.45307>;
        <D.45278>:
        D.44935 = cfg->mempool;
        D.45308 = mono_mempool_alloc (D.44935, 16);
        ins->data.op[1].many_blocks = D.45308;
        D.45309 = ins->data.op[1].many_blocks;
        *D.45309 = end_bb;
        D.45309 = ins->data.op[1].many_blocks;
        D.45310 = D.45309 + 8;
        *D.45310 = 0B;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, end_bb);
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45311>; else goto <D.45312>;
        <D.45311>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44953->next = ins;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        ins->prev = D.44953;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        goto <D.45313>;
        <D.45312>:
        D.44952 = cfg->cbb;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        D.44953 = D.44952->last_ins;
        D.44952->code = D.44953;
        <D.45313>:
        D.45009 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.45010 = D.45009 & 268435456;
        if (D.45010 == 0) goto <D.45314>; else goto <D.45315>;
        <D.45314>:
        D.44935 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.44935, 296);
        D.44936 = cfg->num_bblocks;
        D.45316 = D.44936;
        D.45317 = D.45316 + 1;
        cfg->num_bblocks = D.45317;
        D.45318 = (int) D.45316;
        falsebb->block_num = D.45318;
        D.45309 = ins->data.op[1].many_blocks;
        D.45310 = D.45309 + 8;
        *D.45310 = falsebb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        D.45285 = falsebb->cil_code;
        if (D.45285 != 0B) goto <D.45319>; else goto <D.45320>;
        <D.45319>:
        D.44972 = cfg->cil_offset_to_bb;
        D.45285 = falsebb->cil_code;
        D.45288 = (long int) D.45285;
        D.44974 = cfg->cil_start;
        D.44975 = (long int) D.44974;
        D.45289 = D.45288 - D.44975;
        D.45290 = (long unsigned int) D.45289;
        D.45291 = D.45290 * 8;
        D.45292 = D.44972 + D.45291;
        *D.45292 = falsebb;
        <D.45320>:
        D.44980 = cfg->real_offset;
        falsebb->real_offset = D.44980;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45324>; else goto <D.45321>;
        <D.45324>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 <= 9) goto <D.45322>; else goto <D.45325>;
        <D.45325>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 <= 9) goto <D.45322>; else goto <D.45326>;
        <D.45326>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 <= 9) goto <D.45322>; else goto <D.45321>;
        <D.45322>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        D.44993 = *D.44992;
        if (D.44993 == 0B) goto <D.45327>; else goto <D.45321>;
        <D.45327>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        *D.44992 = falsebb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        goto <D.45323>;
        <D.45321>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 == 0B) goto <D.45328>; else goto <D.45330>;
        <D.45330>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 442) goto <D.45331>; else goto <D.45329>;
        <D.45331>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 759) goto <D.45332>; else goto <D.45329>;
        <D.45332>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 > 9) goto <D.45333>; else goto <D.45329>;
        <D.45333>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 > 9) goto <D.45334>; else goto <D.45329>;
        <D.45334>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 > 9) goto <D.45328>; else goto <D.45329>;
        <D.45328>:
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        <D.45329>:
        <D.45323>:
        D.44952 = cfg->cbb;
        D.44952->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.45335>;
        <D.45315>:
        D.44952 = cfg->cbb;
        D.44952->extended = 1;
        <D.45335>:
        <D.45307>:
      }
      D.45336 = is_nullable_bb->cil_code;
      if (D.45336 != 0B) goto <D.45337>; else goto <D.45338>;
      <D.45337>:
      D.44972 = cfg->cil_offset_to_bb;
      D.45336 = is_nullable_bb->cil_code;
      D.45339 = (long int) D.45336;
      D.44974 = cfg->cil_start;
      D.44975 = (long int) D.44974;
      D.45340 = D.45339 - D.44975;
      D.45341 = (long unsigned int) D.45340;
      D.45342 = D.45341 * 8;
      D.45343 = D.44972 + D.45342;
      *D.45343 = is_nullable_bb;
      <D.45338>:
      D.44980 = cfg->real_offset;
      is_nullable_bb->real_offset = D.44980;
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      if (D.44953 != 0B) goto <D.45347>; else goto <D.45344>;
      <D.45347>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      D.44986 = D.44985 + 64985;
      if (D.44986 <= 9) goto <D.45345>; else goto <D.45348>;
      <D.45348>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      D.44988 = D.44985 + 64878;
      if (D.44988 <= 9) goto <D.45345>; else goto <D.45349>;
      <D.45349>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      D.44990 = D.44985 + 64888;
      if (D.44990 <= 9) goto <D.45345>; else goto <D.45344>;
      <D.45345>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44991 = D.44953->data.op[1].many_blocks;
      D.44992 = D.44991 + 8;
      D.44993 = *D.44992;
      if (D.44993 == 0B) goto <D.45350>; else goto <D.45344>;
      <D.45350>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44991 = D.44953->data.op[1].many_blocks;
      D.44992 = D.44991 + 8;
      *D.44992 = is_nullable_bb;
      D.44952 = cfg->cbb;
      mono_link_bblock (cfg, D.44952, is_nullable_bb);
      goto <D.45346>;
      <D.45344>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      if (D.44953 == 0B) goto <D.45351>; else goto <D.45353>;
      <D.45353>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      if (D.44985 != 442) goto <D.45354>; else goto <D.45352>;
      <D.45354>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      if (D.44985 != 759) goto <D.45355>; else goto <D.45352>;
      <D.45355>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      D.44986 = D.44985 + 64985;
      if (D.44986 > 9) goto <D.45356>; else goto <D.45352>;
      <D.45356>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      D.44988 = D.44985 + 64878;
      if (D.44988 > 9) goto <D.45357>; else goto <D.45352>;
      <D.45357>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      D.44990 = D.44985 + 64888;
      if (D.44990 > 9) goto <D.45351>; else goto <D.45352>;
      <D.45351>:
      D.44952 = cfg->cbb;
      mono_link_bblock (cfg, D.44952, is_nullable_bb);
      <D.45352>:
      <D.45346>:
      D.44952 = cfg->cbb;
      D.44952->next_bb = is_nullable_bb;
      cfg->cbb = is_nullable_bb;
      {
        struct MonoInst * addr;
        struct MonoInst * unbox_call;
        struct MonoMethodSignature * unbox_sig;
        struct MonoInst * var;

        addr = emit_get_gsharedvt_info_klass (cfg, klass, 25);
        D.45210 = &klass->byval_arg;
        var = mono_compile_create_var (cfg, D.45210, 329);
        D.44935 = cfg->mempool;
        unbox_sig = mono_mempool_alloc0 (D.44935, 24);
        D.45210 = &klass->byval_arg;
        unbox_sig->ret = D.45210;
        unbox_sig->param_count = 1;
        D.45358 = mono_defaults.object_class;
        D.45359 = &D.45358->byval_arg;
        unbox_sig->params[0] = D.45359;
        unbox_call = mono_emit_calli (cfg, unbox_sig, &obj, addr, 0B, 0B);
        {
          struct MonoInst * var;

          D.45361 = unbox_call->dreg;
          D.45362 = (unsigned int) D.45361;
          D.45199 = cfg->vreg_to_inst_len;
          if (D.45362 < D.45199) goto <D.45363>; else goto <D.45364>;
          <D.45363>:
          D.45203 = cfg->vreg_to_inst;
          D.45361 = unbox_call->dreg;
          D.45365 = (long unsigned int) D.45361;
          D.45366 = D.45365 * 8;
          D.45367 = D.45203 + D.45366;
          iftmp.386 = *D.45367;
          goto <D.45368>;
          <D.45364>:
          iftmp.386 = 0B;
          <D.45368>:
          var = iftmp.386;
          if (var == 0B) goto <D.45369>; else goto <D.45370>;
          <D.45369>:
          D.45210 = &klass->byval_arg;
          D.45361 = unbox_call->dreg;
          var = mono_compile_create_var_for_vreg (cfg, D.45210, 329, D.45361);
          <D.45370>:
          D.44935 = cfg->mempool;
          addr = mono_mempool_alloc (D.44935, 80);
          addr->data.op[1].const_val = 0;
          D.45371 = addr->data.op[1].const_val;
          addr->data.op[0].const_val = D.45371;
          addr->prev = 0B;
          D.45372 = addr->prev;
          addr->next = D.45372;
          addr->opcode = 314;
          addr->flags = 0;
          addr->type = 0;
          addr->dreg = -1;
          addr->sreg3 = -1;
          D.45373 = addr->sreg3;
          addr->sreg2 = D.45373;
          D.45374 = addr->sreg2;
          addr->sreg1 = D.45374;
          D.44950 = cfg->ip;
          addr->cil_code = D.44950;
          addr->data.op[0].p = var;
          D.45375 = var->flags;
          D.45376 = D.45375 | 16;
          var->flags = D.45376;
          addr->type = 5;
          D.45377 = var->klass;
          addr->klass = D.45377;
          D.45378 = alloc_dreg (cfg, 5);
          D.45379 = (int) D.45378;
          addr->dreg = D.45379;
          cfg->has_indirection = 1;
          D.45216 = cfg->gsharedvt;
          D.45217 = D.45216 != 0;
          D.45218 = (long int) D.45217;
          D.45219 = __builtin_expect (D.45218, 0);
          if (D.45219 != 0) goto <D.45380>; else goto <D.45381>;
          <D.45380>:
          D.45382 = var->data.op[1].vtype;
          D.45383 = mini_is_gsharedvt_variable_type (cfg, D.45382);
          if (D.45383 != 0) goto <D.45384>; else goto <D.45385>;
          <D.45384>:
          handle_gsharedvt_ldaddr (cfg);
          <D.45385>:
          <D.45381>:
          if (0 != 0) goto <D.45386>; else goto <D.45387>;
          <D.45386>:
          {
            struct MonoInst * var1;
            struct MonoInst * var2;

            D.45389 = var->dreg;
            D.45390 = D.45389 + 1;
            D.45391 = (unsigned int) D.45390;
            D.45199 = cfg->vreg_to_inst_len;
            if (D.45391 < D.45199) goto <D.45392>; else goto <D.45393>;
            <D.45392>:
            D.45203 = cfg->vreg_to_inst;
            D.45389 = var->dreg;
            D.45394 = (sizetype) D.45389;
            D.45395 = D.45394 + 1;
            D.45396 = D.45395 * 8;
            D.45397 = D.45203 + D.45396;
            iftmp.387 = *D.45397;
            goto <D.45398>;
            <D.45393>:
            iftmp.387 = 0B;
            <D.45398>:
            var1 = iftmp.387;
            D.45389 = var->dreg;
            D.45400 = D.45389 + 2;
            D.45401 = (unsigned int) D.45400;
            D.45199 = cfg->vreg_to_inst_len;
            if (D.45401 < D.45199) goto <D.45402>; else goto <D.45403>;
            <D.45402>:
            D.45203 = cfg->vreg_to_inst;
            D.45389 = var->dreg;
            D.45394 = (sizetype) D.45389;
            D.45404 = D.45394 + 2;
            D.45405 = D.45404 * 8;
            D.45406 = D.45203 + D.45405;
            iftmp.388 = *D.45406;
            goto <D.45407>;
            <D.45403>:
            iftmp.388 = 0B;
            <D.45407>:
            var2 = iftmp.388;
            D.45408 = var1 == 0B;
            D.45409 = (long int) D.45408;
            D.45410 = __builtin_expect (D.45409, 0);
            if (D.45410 != 0) goto <D.45411>; else goto <D.45412>;
            <D.45411>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3706, "var1");
            <D.45412>:
            D.45413 = var2 == 0B;
            D.45414 = (long int) D.45413;
            D.45415 = __builtin_expect (D.45414, 0);
            if (D.45415 != 0) goto <D.45416>; else goto <D.45417>;
            <D.45416>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3706, "var2");
            <D.45417>:
            D.45418 = var1->flags;
            D.45419 = D.45418 | 16;
            var1->flags = D.45419;
            D.45420 = var2->flags;
            D.45421 = D.45420 | 16;
            var2->flags = D.45421;
          }
          <D.45387>:
        }
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45422>; else goto <D.45423>;
        <D.45422>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44953->next = addr;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        addr->prev = D.44953;
        D.44952 = cfg->cbb;
        D.44952->last_ins = addr;
        goto <D.45424>;
        <D.45423>:
        D.44952 = cfg->cbb;
        D.44952 = cfg->cbb;
        D.44952->last_ins = addr;
        D.44953 = D.44952->last_ins;
        D.44952->code = D.44953;
        <D.45424>:
        addr->dreg = addr_reg;
      }
      {
        struct MonoInst * ins;
        struct MonoBasicBlock * falsebb;

        D.44935 = cfg->mempool;
        ins = mono_mempool_alloc (D.44935, 80);
        ins->data.op[1].const_val = 0;
        D.45425 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.45425;
        ins->prev = 0B;
        D.45426 = ins->prev;
        ins->next = D.45426;
        ins->opcode = 442;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.45427 = ins->sreg3;
        ins->sreg2 = D.45427;
        D.45428 = ins->sreg2;
        ins->sreg1 = D.45428;
        D.44950 = cfg->ip;
        ins->cil_code = D.44950;
        if (1 != 0) goto <D.45429>; else goto <D.45430>;
        <D.45429>:
        D.44935 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.44935, 296);
        D.44936 = cfg->num_bblocks;
        D.45431 = D.44936;
        D.45432 = D.45431 + 1;
        cfg->num_bblocks = D.45432;
        D.45433 = (int) D.45431;
        falsebb->block_num = D.45433;
        ins->data.op[0].target_block = end_bb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, end_bb);
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45434>; else goto <D.45435>;
        <D.45434>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44953->next = ins;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        ins->prev = D.44953;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        goto <D.45436>;
        <D.45435>:
        D.44952 = cfg->cbb;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        D.44953 = D.44952->last_ins;
        D.44952->code = D.44953;
        <D.45436>:
        D.45437 = falsebb->cil_code;
        if (D.45437 != 0B) goto <D.45438>; else goto <D.45439>;
        <D.45438>:
        D.44972 = cfg->cil_offset_to_bb;
        D.45437 = falsebb->cil_code;
        D.45440 = (long int) D.45437;
        D.44974 = cfg->cil_start;
        D.44975 = (long int) D.44974;
        D.45441 = D.45440 - D.44975;
        D.45442 = (long unsigned int) D.45441;
        D.45443 = D.45442 * 8;
        D.45444 = D.44972 + D.45443;
        *D.45444 = falsebb;
        <D.45439>:
        D.44980 = cfg->real_offset;
        falsebb->real_offset = D.44980;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45448>; else goto <D.45445>;
        <D.45448>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 <= 9) goto <D.45446>; else goto <D.45449>;
        <D.45449>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 <= 9) goto <D.45446>; else goto <D.45450>;
        <D.45450>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 <= 9) goto <D.45446>; else goto <D.45445>;
        <D.45446>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        D.44993 = *D.44992;
        if (D.44993 == 0B) goto <D.45451>; else goto <D.45445>;
        <D.45451>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        *D.44992 = falsebb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        goto <D.45447>;
        <D.45445>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 == 0B) goto <D.45452>; else goto <D.45454>;
        <D.45454>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 442) goto <D.45455>; else goto <D.45453>;
        <D.45455>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 759) goto <D.45456>; else goto <D.45453>;
        <D.45456>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 > 9) goto <D.45457>; else goto <D.45453>;
        <D.45457>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 > 9) goto <D.45458>; else goto <D.45453>;
        <D.45458>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 > 9) goto <D.45452>; else goto <D.45453>;
        <D.45452>:
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        <D.45453>:
        <D.45447>:
        D.44952 = cfg->cbb;
        D.44952->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.45459>;
        <D.45430>:
        D.44935 = cfg->mempool;
        D.45460 = mono_mempool_alloc (D.44935, 16);
        ins->data.op[1].many_blocks = D.45460;
        D.45461 = ins->data.op[1].many_blocks;
        *D.45461 = end_bb;
        D.45461 = ins->data.op[1].many_blocks;
        D.45462 = D.45461 + 8;
        *D.45462 = 0B;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, end_bb);
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45463>; else goto <D.45464>;
        <D.45463>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44953->next = ins;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        ins->prev = D.44953;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        goto <D.45465>;
        <D.45464>:
        D.44952 = cfg->cbb;
        D.44952 = cfg->cbb;
        D.44952->last_ins = ins;
        D.44953 = D.44952->last_ins;
        D.44952->code = D.44953;
        <D.45465>:
        D.45009 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.45010 = D.45009 & 268435456;
        if (D.45010 == 0) goto <D.45466>; else goto <D.45467>;
        <D.45466>:
        D.44935 = cfg->mempool;
        falsebb = mono_mempool_alloc0 (D.44935, 296);
        D.44936 = cfg->num_bblocks;
        D.45468 = D.44936;
        D.45469 = D.45468 + 1;
        cfg->num_bblocks = D.45469;
        D.45470 = (int) D.45468;
        falsebb->block_num = D.45470;
        D.45461 = ins->data.op[1].many_blocks;
        D.45462 = D.45461 + 8;
        *D.45462 = falsebb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        D.45437 = falsebb->cil_code;
        if (D.45437 != 0B) goto <D.45471>; else goto <D.45472>;
        <D.45471>:
        D.44972 = cfg->cil_offset_to_bb;
        D.45437 = falsebb->cil_code;
        D.45440 = (long int) D.45437;
        D.44974 = cfg->cil_start;
        D.44975 = (long int) D.44974;
        D.45441 = D.45440 - D.44975;
        D.45442 = (long unsigned int) D.45441;
        D.45443 = D.45442 * 8;
        D.45444 = D.44972 + D.45443;
        *D.45444 = falsebb;
        <D.45472>:
        D.44980 = cfg->real_offset;
        falsebb->real_offset = D.44980;
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 != 0B) goto <D.45476>; else goto <D.45473>;
        <D.45476>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 <= 9) goto <D.45474>; else goto <D.45477>;
        <D.45477>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 <= 9) goto <D.45474>; else goto <D.45478>;
        <D.45478>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 <= 9) goto <D.45474>; else goto <D.45473>;
        <D.45474>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        D.44993 = *D.44992;
        if (D.44993 == 0B) goto <D.45479>; else goto <D.45473>;
        <D.45479>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44991 = D.44953->data.op[1].many_blocks;
        D.44992 = D.44991 + 8;
        *D.44992 = falsebb;
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        goto <D.45475>;
        <D.45473>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        if (D.44953 == 0B) goto <D.45480>; else goto <D.45482>;
        <D.45482>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 442) goto <D.45483>; else goto <D.45481>;
        <D.45483>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        if (D.44985 != 759) goto <D.45484>; else goto <D.45481>;
        <D.45484>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44986 = D.44985 + 64985;
        if (D.44986 > 9) goto <D.45485>; else goto <D.45481>;
        <D.45485>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44988 = D.44985 + 64878;
        if (D.44988 > 9) goto <D.45486>; else goto <D.45481>;
        <D.45486>:
        D.44952 = cfg->cbb;
        D.44953 = D.44952->last_ins;
        D.44985 = D.44953->opcode;
        D.44990 = D.44985 + 64888;
        if (D.44990 > 9) goto <D.45480>; else goto <D.45481>;
        <D.45480>:
        D.44952 = cfg->cbb;
        mono_link_bblock (cfg, D.44952, falsebb);
        <D.45481>:
        <D.45475>:
        D.44952 = cfg->cbb;
        D.44952->next_bb = falsebb;
        cfg->cbb = falsebb;
        goto <D.45487>;
        <D.45467>:
        D.44952 = cfg->cbb;
        D.44952->extended = 1;
        <D.45487>:
        <D.45459>:
      }
      D.45488 = end_bb->cil_code;
      if (D.45488 != 0B) goto <D.45489>; else goto <D.45490>;
      <D.45489>:
      D.44972 = cfg->cil_offset_to_bb;
      D.45488 = end_bb->cil_code;
      D.45491 = (long int) D.45488;
      D.44974 = cfg->cil_start;
      D.44975 = (long int) D.44974;
      D.45492 = D.45491 - D.44975;
      D.45493 = (long unsigned int) D.45492;
      D.45494 = D.45493 * 8;
      D.45495 = D.44972 + D.45494;
      *D.45495 = end_bb;
      <D.45490>:
      D.44980 = cfg->real_offset;
      end_bb->real_offset = D.44980;
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      if (D.44953 != 0B) goto <D.45499>; else goto <D.45496>;
      <D.45499>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      D.44986 = D.44985 + 64985;
      if (D.44986 <= 9) goto <D.45497>; else goto <D.45500>;
      <D.45500>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      D.44988 = D.44985 + 64878;
      if (D.44988 <= 9) goto <D.45497>; else goto <D.45501>;
      <D.45501>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      D.44990 = D.44985 + 64888;
      if (D.44990 <= 9) goto <D.45497>; else goto <D.45496>;
      <D.45497>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44991 = D.44953->data.op[1].many_blocks;
      D.44992 = D.44991 + 8;
      D.44993 = *D.44992;
      if (D.44993 == 0B) goto <D.45502>; else goto <D.45496>;
      <D.45502>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44991 = D.44953->data.op[1].many_blocks;
      D.44992 = D.44991 + 8;
      *D.44992 = end_bb;
      D.44952 = cfg->cbb;
      mono_link_bblock (cfg, D.44952, end_bb);
      goto <D.45498>;
      <D.45496>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      if (D.44953 == 0B) goto <D.45503>; else goto <D.45505>;
      <D.45505>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      if (D.44985 != 442) goto <D.45506>; else goto <D.45504>;
      <D.45506>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      if (D.44985 != 759) goto <D.45507>; else goto <D.45504>;
      <D.45507>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      D.44986 = D.44985 + 64985;
      if (D.44986 > 9) goto <D.45508>; else goto <D.45504>;
      <D.45508>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      D.44988 = D.44985 + 64878;
      if (D.44988 > 9) goto <D.45509>; else goto <D.45504>;
      <D.45509>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44985 = D.44953->opcode;
      D.44990 = D.44985 + 64888;
      if (D.44990 > 9) goto <D.45503>; else goto <D.45504>;
      <D.45503>:
      D.44952 = cfg->cbb;
      mono_link_bblock (cfg, D.44952, end_bb);
      <D.45504>:
      <D.45498>:
      D.44952 = cfg->cbb;
      D.44952->next_bb = end_bb;
      cfg->cbb = end_bb;
      D.44935 = cfg->mempool;
      ins = mono_mempool_alloc (D.44935, 80);
      ins->data.op[1].const_val = 0;
      D.45510 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.45510;
      ins->prev = 0B;
      D.45511 = ins->prev;
      ins->next = D.45511;
      D.45210 = &klass->byval_arg;
      D.45512 = mono_type_to_load_membase (cfg, D.45210);
      D.45513 = (short unsigned int) D.45512;
      ins->opcode = D.45513;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.45514 = ins->sreg3;
      ins->sreg2 = D.45514;
      D.45515 = ins->sreg2;
      ins->sreg1 = D.45515;
      D.44950 = cfg->ip;
      ins->cil_code = D.44950;
      ins->dreg = 0;
      ins->sreg1 = addr_reg;
      ins->data.op[0].const_val = 0;
      ins->type = 1;
      D.45210 = &klass->byval_arg;
      type_to_eval_stack_type (cfg, D.45210, ins);
      D.45516 = ins->type;
      D.45517 = (<unnamed type>) D.45516;
      D.45518 = alloc_dreg (cfg, D.45517);
      D.45519 = (int) D.45518;
      ins->dreg = D.45519;
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      if (D.44953 != 0B) goto <D.45520>; else goto <D.45521>;
      <D.45520>:
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      D.44953->next = ins;
      D.44952 = cfg->cbb;
      D.44953 = D.44952->last_ins;
      ins->prev = D.44953;
      D.44952 = cfg->cbb;
      D.44952->last_ins = ins;
      goto <D.45522>;
      <D.45521>:
      D.44952 = cfg->cbb;
      D.44952 = cfg->cbb;
      D.44952->last_ins = ins;
      D.44953 = D.44952->last_ins;
      D.44952->code = D.44953;
      <D.45522>:
      D.44952 = cfg->cbb;
      *out_cbb = D.44952;
      D.45523 = ins;
      return D.45523;
    }
  finally
    {
      args = {CLOBBER};
    }
}


mini_class_has_reference_variant_generic_argument (struct MonoCompile * cfg, struct MonoClass * klass, int context_used)
{
  struct MonoGenericClass * D.45526;
  struct MonoClass * D.45529;
  struct MonoGenericContainer * D.45533;
  gboolean D.45536;
  struct MonoGenericParamFull * D.45537;
  long unsigned int D.45538;
  long unsigned int D.45539;
  struct MonoGenericParamFull * D.45540;
  short unsigned int D.45541;
  int D.45542;
  int D.45543;
  int D.45546;
  <unnamed-signed:31> D.45549;
  int D.45550;
  int i;
  struct MonoGenericContainer * container;
  struct MonoGenericInst * ginst;

  D.45526 = klass->generic_class;
  if (D.45526 != 0B) goto <D.45527>; else goto <D.45528>;
  <D.45527>:
  D.45526 = klass->generic_class;
  D.45529 = D.45526->container_class;
  container = D.45529->generic_container;
  D.45526 = klass->generic_class;
  ginst = D.45526->context.class_inst;
  goto <D.45530>;
  <D.45528>:
  D.45533 = klass->generic_container;
  if (D.45533 != 0B) goto <D.45534>; else goto <D.45531>;
  <D.45534>:
  if (context_used != 0) goto <D.45535>; else goto <D.45531>;
  <D.45535>:
  container = klass->generic_container;
  ginst = container->context.class_inst;
  goto <D.45532>;
  <D.45531>:
  D.45536 = 0;
  return D.45536;
  <D.45532>:
  <D.45530>:
  i = 0;
  goto <D.26428>;
  <D.26427>:
  {
    struct MonoType * type;

    D.45537 = container->type_params;
    D.45538 = (long unsigned int) i;
    D.45539 = D.45538 * 56;
    D.45540 = D.45537 + D.45539;
    D.45541 = D.45540->info.flags;
    D.45542 = (int) D.45541;
    D.45543 = D.45542 & 3;
    if (D.45543 == 0) goto <D.45544>; else goto <D.45545>;
    <D.45544>:
    // predicted unlikely by continue predictor.
    goto <D.26426>;
    <D.45545>:
    type = ginst->type_argv[i];
    D.45546 = mini_type_is_reference (cfg, type);
    if (D.45546 != 0) goto <D.45547>; else goto <D.45548>;
    <D.45547>:
    D.45536 = 1;
    return D.45536;
    <D.45548>:
  }
  <D.26426>:
  i = i + 1;
  <D.26428>:
  D.45549 = container->type_argc;
  D.45550 = (int) D.45549;
  if (D.45550 > i) goto <D.26427>; else goto <D.26429>;
  <D.26429>:
  D.45536 = 0;
  return D.45536;
}


handle_castclass (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * src, int context_used)
{
  unsigned int D.45552;
  struct MonoMemPool * D.45557;
  void * D.45558;
  struct MonoInst * D.45559;
  long int D.45560;
  struct MonoInst * D.45561;
  int D.45562;
  int D.45563;
  const unsigned char * D.45564;
  unsigned int D.45565;
  int D.45566;
  int D.45567;
  struct MonoBasicBlock * D.45568;
  struct MonoInst * D.45569;
  struct MonoInst * D.45573;
  unsigned int D.45574;
  unsigned int D.45575;
  unsigned int D.45576;
  int D.45577;
  long int D.45578;
  struct MonoInst * D.45579;
  int D.45580;
  int D.45581;
  long int D.45585;
  struct MonoInst * D.45586;
  int D.45587;
  int D.45588;
  unsigned int D.45591;
  unsigned int D.45592;
  int D.45593;
  unsigned char * D.45597;
  struct MonoBasicBlock * * D.45600;
  long int D.45601;
  unsigned char * D.45602;
  long int D.45603;
  long int D.45604;
  long unsigned int D.45605;
  long unsigned int D.45606;
  struct MonoBasicBlock * * D.45607;
  unsigned int D.45608;
  short unsigned int D.45613;
  short unsigned int D.45614;
  short unsigned int D.45616;
  short unsigned int D.45618;
  struct MonoBasicBlock * * D.45619;
  struct MonoBasicBlock * * D.45620;
  struct MonoBasicBlock * D.45621;
  void * D.45631;
  struct MonoBasicBlock * * D.45632;
  struct MonoBasicBlock * * D.45633;
  long unsigned int D.45637;
  long unsigned int D.45638;
  unsigned int D.45641;
  unsigned int D.45642;
  int D.45643;
  unsigned int D.45661;
  unsigned int D.45662;
  long int D.45665;
  struct MonoInst * D.45666;
  int D.45667;
  int D.45668;
  unsigned int D.45673;
  long int D.45674;
  struct MonoInst * D.45675;
  int D.45676;
  int D.45677;
  unsigned char D.45683;
  long unsigned int D.45685;
  unsigned int D.45687;
  unsigned int D.45688;
  unsigned int D.45690;
  struct MonoDomain * D.45694;
  long int D.45697;
  struct MonoInst * D.45698;
  int D.45699;
  int D.45700;
  long int vt.389;
  long int D.45706;
  struct MonoInst * D.45707;
  int D.45708;
  int D.45709;
  long int D.45713;
  struct MonoInst * D.45714;
  int D.45715;
  int D.45716;
  long int klass.390;
  long int D.45721;
  struct MonoInst * D.45722;
  int D.45723;
  int D.45724;
  long int D.45728;
  struct MonoInst * D.45729;
  int D.45730;
  int D.45731;
  unsigned char * D.45735;
  long int D.45738;
  long int D.45739;
  long unsigned int D.45740;
  long unsigned int D.45741;
  struct MonoBasicBlock * * D.45742;
  struct MonoBasicBlock * is_null_bb;
  int obj_reg;
  int vtable_reg;
  struct MonoInst * klass_inst;

  obj_reg = src->dreg;
  D.45552 = alloc_preg (cfg);
  vtable_reg = (int) D.45552;
  klass_inst = 0B;
  if (context_used != 0) goto <D.45553>; else goto <D.45554>;
  <D.45553>:
  {
    struct MonoInst * args[3];

    try
      {
        mini_class_has_reference_variant_generic_argument (cfg, klass, context_used);
        if (1 != 0) goto <D.45555>; else goto <D.45556>;
        <D.45555>:
        {
          struct MonoMethod * mono_castclass;
          struct MonoInst * cache_ins;

          mono_castclass = mono_marshal_get_castclass_with_cache ();
          cache_ins = emit_get_rgctx_klass (cfg, context_used, klass, 12);
          args[0] = src;
          D.45557 = cfg->mempool;
          D.45558 = mono_mempool_alloc (D.45557, 80);
          args[1] = D.45558;
          D.45559 = args[1];
          D.45559 = args[1];
          D.45559->data.op[1].const_val = 0;
          D.45560 = D.45559->data.op[1].const_val;
          D.45559->data.op[0].const_val = D.45560;
          D.45559 = args[1];
          D.45559 = args[1];
          D.45559->prev = 0B;
          D.45561 = D.45559->prev;
          D.45559->next = D.45561;
          D.45559 = args[1];
          D.45559->opcode = 388;
          D.45559 = args[1];
          D.45559->flags = 0;
          D.45559 = args[1];
          D.45559->type = 0;
          D.45559 = args[1];
          D.45559->dreg = -1;
          D.45559 = args[1];
          D.45559 = args[1];
          D.45559 = args[1];
          D.45559->sreg3 = -1;
          D.45562 = D.45559->sreg3;
          D.45559->sreg2 = D.45562;
          D.45563 = D.45559->sreg2;
          D.45559->sreg1 = D.45563;
          D.45559 = args[1];
          D.45564 = cfg->ip;
          D.45559->cil_code = D.45564;
          D.45559 = args[1];
          D.45565 = alloc_preg (cfg);
          D.45566 = (int) D.45565;
          D.45559->dreg = D.45566;
          D.45559 = args[1];
          D.45567 = cache_ins->dreg;
          D.45559->sreg1 = D.45567;
          D.45559 = args[1];
          D.45559->data.op[0].const_val = 8;
          D.45559 = args[1];
          D.45559->type = 1;
          D.45568 = cfg->cbb;
          D.45569 = D.45568->last_ins;
          if (D.45569 != 0B) goto <D.45570>; else goto <D.45571>;
          <D.45570>:
          D.45568 = cfg->cbb;
          D.45569 = D.45568->last_ins;
          D.45559 = args[1];
          D.45569->next = D.45559;
          D.45559 = args[1];
          D.45568 = cfg->cbb;
          D.45569 = D.45568->last_ins;
          D.45559->prev = D.45569;
          D.45568 = cfg->cbb;
          D.45559 = args[1];
          D.45568->last_ins = D.45559;
          goto <D.45572>;
          <D.45571>:
          D.45568 = cfg->cbb;
          D.45568 = cfg->cbb;
          D.45559 = args[1];
          D.45568->last_ins = D.45559;
          D.45569 = D.45568->last_ins;
          D.45568->code = D.45569;
          <D.45572>:
          args[2] = cache_ins;
          D.45573 = mono_emit_method_call (cfg, mono_castclass, &args, 0B);
          return D.45573;
        }
        <D.45556>:
        klass_inst = emit_get_rgctx_klass (cfg, context_used, klass, 1);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
  <D.45554>:
  D.45557 = cfg->mempool;
  is_null_bb = mono_mempool_alloc0 (D.45557, 296);
  D.45574 = cfg->num_bblocks;
  D.45575 = D.45574;
  D.45576 = D.45575 + 1;
  cfg->num_bblocks = D.45576;
  D.45577 = (int) D.45575;
  is_null_bb->block_num = D.45577;
  {
    struct MonoInst * inst;

    D.45557 = cfg->mempool;
    inst = mono_mempool_alloc (D.45557, 80);
    inst->data.op[1].const_val = 0;
    D.45578 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.45578;
    inst->prev = 0B;
    D.45579 = inst->prev;
    inst->next = D.45579;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.45580 = inst->sreg3;
    inst->sreg2 = D.45580;
    D.45581 = inst->sreg2;
    inst->sreg1 = D.45581;
    D.45564 = cfg->ip;
    inst->cil_code = D.45564;
    inst->dreg = -1;
    inst->sreg1 = obj_reg;
    inst->data.op[1].const_val = 0;
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    if (D.45569 != 0B) goto <D.45582>; else goto <D.45583>;
    <D.45582>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45569->next = inst;
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    inst->prev = D.45569;
    D.45568 = cfg->cbb;
    D.45568->last_ins = inst;
    goto <D.45584>;
    <D.45583>:
    D.45568 = cfg->cbb;
    D.45568 = cfg->cbb;
    D.45568->last_ins = inst;
    D.45569 = D.45568->last_ins;
    D.45568->code = D.45569;
    <D.45584>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.45557 = cfg->mempool;
    ins = mono_mempool_alloc (D.45557, 80);
    ins->data.op[1].const_val = 0;
    D.45585 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.45585;
    ins->prev = 0B;
    D.45586 = ins->prev;
    ins->next = D.45586;
    ins->opcode = 551;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.45587 = ins->sreg3;
    ins->sreg2 = D.45587;
    D.45588 = ins->sreg2;
    ins->sreg1 = D.45588;
    D.45564 = cfg->ip;
    ins->cil_code = D.45564;
    if (0 != 0) goto <D.45589>; else goto <D.45590>;
    <D.45589>:
    D.45557 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.45557, 296);
    D.45574 = cfg->num_bblocks;
    D.45591 = D.45574;
    D.45592 = D.45591 + 1;
    cfg->num_bblocks = D.45592;
    D.45593 = (int) D.45591;
    falsebb->block_num = D.45593;
    ins->data.op[0].target_block = is_null_bb;
    D.45568 = cfg->cbb;
    mono_link_bblock (cfg, D.45568, is_null_bb);
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    if (D.45569 != 0B) goto <D.45594>; else goto <D.45595>;
    <D.45594>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45569->next = ins;
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    ins->prev = D.45569;
    D.45568 = cfg->cbb;
    D.45568->last_ins = ins;
    goto <D.45596>;
    <D.45595>:
    D.45568 = cfg->cbb;
    D.45568 = cfg->cbb;
    D.45568->last_ins = ins;
    D.45569 = D.45568->last_ins;
    D.45568->code = D.45569;
    <D.45596>:
    D.45597 = falsebb->cil_code;
    if (D.45597 != 0B) goto <D.45598>; else goto <D.45599>;
    <D.45598>:
    D.45600 = cfg->cil_offset_to_bb;
    D.45597 = falsebb->cil_code;
    D.45601 = (long int) D.45597;
    D.45602 = cfg->cil_start;
    D.45603 = (long int) D.45602;
    D.45604 = D.45601 - D.45603;
    D.45605 = (long unsigned int) D.45604;
    D.45606 = D.45605 * 8;
    D.45607 = D.45600 + D.45606;
    *D.45607 = falsebb;
    <D.45599>:
    D.45608 = cfg->real_offset;
    falsebb->real_offset = D.45608;
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    if (D.45569 != 0B) goto <D.45612>; else goto <D.45609>;
    <D.45612>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45613 = D.45569->opcode;
    D.45614 = D.45613 + 64985;
    if (D.45614 <= 9) goto <D.45610>; else goto <D.45615>;
    <D.45615>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45613 = D.45569->opcode;
    D.45616 = D.45613 + 64878;
    if (D.45616 <= 9) goto <D.45610>; else goto <D.45617>;
    <D.45617>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45613 = D.45569->opcode;
    D.45618 = D.45613 + 64888;
    if (D.45618 <= 9) goto <D.45610>; else goto <D.45609>;
    <D.45610>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45619 = D.45569->data.op[1].many_blocks;
    D.45620 = D.45619 + 8;
    D.45621 = *D.45620;
    if (D.45621 == 0B) goto <D.45622>; else goto <D.45609>;
    <D.45622>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45619 = D.45569->data.op[1].many_blocks;
    D.45620 = D.45619 + 8;
    *D.45620 = falsebb;
    D.45568 = cfg->cbb;
    mono_link_bblock (cfg, D.45568, falsebb);
    goto <D.45611>;
    <D.45609>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    if (D.45569 == 0B) goto <D.45623>; else goto <D.45625>;
    <D.45625>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45613 = D.45569->opcode;
    if (D.45613 != 442) goto <D.45626>; else goto <D.45624>;
    <D.45626>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45613 = D.45569->opcode;
    if (D.45613 != 759) goto <D.45627>; else goto <D.45624>;
    <D.45627>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45613 = D.45569->opcode;
    D.45614 = D.45613 + 64985;
    if (D.45614 > 9) goto <D.45628>; else goto <D.45624>;
    <D.45628>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45613 = D.45569->opcode;
    D.45616 = D.45613 + 64878;
    if (D.45616 > 9) goto <D.45629>; else goto <D.45624>;
    <D.45629>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45613 = D.45569->opcode;
    D.45618 = D.45613 + 64888;
    if (D.45618 > 9) goto <D.45623>; else goto <D.45624>;
    <D.45623>:
    D.45568 = cfg->cbb;
    mono_link_bblock (cfg, D.45568, falsebb);
    <D.45624>:
    <D.45611>:
    D.45568 = cfg->cbb;
    D.45568->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.45630>;
    <D.45590>:
    D.45557 = cfg->mempool;
    D.45631 = mono_mempool_alloc (D.45557, 16);
    ins->data.op[1].many_blocks = D.45631;
    D.45632 = ins->data.op[1].many_blocks;
    *D.45632 = is_null_bb;
    D.45632 = ins->data.op[1].many_blocks;
    D.45633 = D.45632 + 8;
    *D.45633 = 0B;
    D.45568 = cfg->cbb;
    mono_link_bblock (cfg, D.45568, is_null_bb);
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    if (D.45569 != 0B) goto <D.45634>; else goto <D.45635>;
    <D.45634>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45569->next = ins;
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    ins->prev = D.45569;
    D.45568 = cfg->cbb;
    D.45568->last_ins = ins;
    goto <D.45636>;
    <D.45635>:
    D.45568 = cfg->cbb;
    D.45568 = cfg->cbb;
    D.45568->last_ins = ins;
    D.45569 = D.45568->last_ins;
    D.45568->code = D.45569;
    <D.45636>:
    D.45637 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.45638 = D.45637 & 268435456;
    if (D.45638 == 0) goto <D.45639>; else goto <D.45640>;
    <D.45639>:
    D.45557 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.45557, 296);
    D.45574 = cfg->num_bblocks;
    D.45641 = D.45574;
    D.45642 = D.45641 + 1;
    cfg->num_bblocks = D.45642;
    D.45643 = (int) D.45641;
    falsebb->block_num = D.45643;
    D.45632 = ins->data.op[1].many_blocks;
    D.45633 = D.45632 + 8;
    *D.45633 = falsebb;
    D.45568 = cfg->cbb;
    mono_link_bblock (cfg, D.45568, falsebb);
    D.45597 = falsebb->cil_code;
    if (D.45597 != 0B) goto <D.45644>; else goto <D.45645>;
    <D.45644>:
    D.45600 = cfg->cil_offset_to_bb;
    D.45597 = falsebb->cil_code;
    D.45601 = (long int) D.45597;
    D.45602 = cfg->cil_start;
    D.45603 = (long int) D.45602;
    D.45604 = D.45601 - D.45603;
    D.45605 = (long unsigned int) D.45604;
    D.45606 = D.45605 * 8;
    D.45607 = D.45600 + D.45606;
    *D.45607 = falsebb;
    <D.45645>:
    D.45608 = cfg->real_offset;
    falsebb->real_offset = D.45608;
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    if (D.45569 != 0B) goto <D.45649>; else goto <D.45646>;
    <D.45649>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45613 = D.45569->opcode;
    D.45614 = D.45613 + 64985;
    if (D.45614 <= 9) goto <D.45647>; else goto <D.45650>;
    <D.45650>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45613 = D.45569->opcode;
    D.45616 = D.45613 + 64878;
    if (D.45616 <= 9) goto <D.45647>; else goto <D.45651>;
    <D.45651>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45613 = D.45569->opcode;
    D.45618 = D.45613 + 64888;
    if (D.45618 <= 9) goto <D.45647>; else goto <D.45646>;
    <D.45647>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45619 = D.45569->data.op[1].many_blocks;
    D.45620 = D.45619 + 8;
    D.45621 = *D.45620;
    if (D.45621 == 0B) goto <D.45652>; else goto <D.45646>;
    <D.45652>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45619 = D.45569->data.op[1].many_blocks;
    D.45620 = D.45619 + 8;
    *D.45620 = falsebb;
    D.45568 = cfg->cbb;
    mono_link_bblock (cfg, D.45568, falsebb);
    goto <D.45648>;
    <D.45646>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    if (D.45569 == 0B) goto <D.45653>; else goto <D.45655>;
    <D.45655>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45613 = D.45569->opcode;
    if (D.45613 != 442) goto <D.45656>; else goto <D.45654>;
    <D.45656>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45613 = D.45569->opcode;
    if (D.45613 != 759) goto <D.45657>; else goto <D.45654>;
    <D.45657>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45613 = D.45569->opcode;
    D.45614 = D.45613 + 64985;
    if (D.45614 > 9) goto <D.45658>; else goto <D.45654>;
    <D.45658>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45613 = D.45569->opcode;
    D.45616 = D.45613 + 64878;
    if (D.45616 > 9) goto <D.45659>; else goto <D.45654>;
    <D.45659>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45613 = D.45569->opcode;
    D.45618 = D.45613 + 64888;
    if (D.45618 > 9) goto <D.45653>; else goto <D.45654>;
    <D.45653>:
    D.45568 = cfg->cbb;
    mono_link_bblock (cfg, D.45568, falsebb);
    <D.45654>:
    <D.45648>:
    D.45568 = cfg->cbb;
    D.45568->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.45660>;
    <D.45640>:
    D.45568 = cfg->cbb;
    D.45568->extended = 1;
    <D.45660>:
    <D.45630>:
  }
  save_cast_details (cfg, klass, obj_reg, 0, 0B);
  D.45661 = klass->flags;
  D.45662 = D.45661 & 32;
  if (D.45662 != 0) goto <D.45663>; else goto <D.45664>;
  <D.45663>:
  {
    struct MonoInst * inst;

    D.45557 = cfg->mempool;
    inst = mono_mempool_alloc (D.45557, 80);
    inst->data.op[1].const_val = 0;
    D.45665 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.45665;
    inst->prev = 0B;
    D.45666 = inst->prev;
    inst->next = D.45666;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.45667 = inst->sreg3;
    inst->sreg2 = D.45667;
    D.45668 = inst->sreg2;
    inst->sreg1 = D.45668;
    D.45564 = cfg->ip;
    inst->cil_code = D.45564;
    inst->dreg = vtable_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 0;
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    if (D.45569 != 0B) goto <D.45669>; else goto <D.45670>;
    <D.45669>:
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    D.45569->next = inst;
    D.45568 = cfg->cbb;
    D.45569 = D.45568->last_ins;
    inst->prev = D.45569;
    D.45568 = cfg->cbb;
    D.45568->last_ins = inst;
    goto <D.45671>;
    <D.45670>:
    D.45568 = cfg->cbb;
    D.45568 = cfg->cbb;
    D.45568->last_ins = inst;
    D.45569 = D.45568->last_ins;
    D.45568->code = D.45569;
    <D.45671>:
  }
  mini_emit_iface_cast (cfg, vtable_reg, klass, 0B, 0B);
  goto <D.45672>;
  <D.45664>:
  {
    int klass_reg;

    D.45673 = alloc_preg (cfg);
    klass_reg = (int) D.45673;
    {
      struct MonoInst * inst;

      D.45557 = cfg->mempool;
      inst = mono_mempool_alloc (D.45557, 80);
      inst->data.op[1].const_val = 0;
      D.45674 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45674;
      inst->prev = 0B;
      D.45675 = inst->prev;
      inst->next = D.45675;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45676 = inst->sreg3;
      inst->sreg2 = D.45676;
      D.45677 = inst->sreg2;
      inst->sreg1 = D.45677;
      D.45564 = cfg->ip;
      inst->cil_code = D.45564;
      inst->dreg = vtable_reg;
      inst->sreg1 = obj_reg;
      inst->data.op[0].const_val = 0;
      D.45568 = cfg->cbb;
      D.45569 = D.45568->last_ins;
      if (D.45569 != 0B) goto <D.45678>; else goto <D.45679>;
      <D.45678>:
      D.45568 = cfg->cbb;
      D.45569 = D.45568->last_ins;
      D.45569->next = inst;
      D.45568 = cfg->cbb;
      D.45569 = D.45568->last_ins;
      inst->prev = D.45569;
      D.45568 = cfg->cbb;
      D.45568->last_ins = inst;
      goto <D.45680>;
      <D.45679>:
      D.45568 = cfg->cbb;
      D.45568 = cfg->cbb;
      D.45568->last_ins = inst;
      D.45569 = D.45568->last_ins;
      D.45568->code = D.45569;
      <D.45680>:
    }
    D.45683 = klass->rank;
    if (D.45683 == 0) goto <D.45684>; else goto <D.45681>;
    <D.45684>:
    D.45637 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.45685 = D.45637 & 33554432;
    if (D.45685 == 0) goto <D.45686>; else goto <D.45681>;
    <D.45686>:
    D.45687 = cfg->opt;
    D.45688 = D.45687 & 512;
    if (D.45688 == 0) goto <D.45689>; else goto <D.45681>;
    <D.45689>:
    D.45661 = klass->flags;
    D.45690 = D.45661 & 256;
    if (D.45690 != 0) goto <D.45691>; else goto <D.45681>;
    <D.45691>:
    if (0 != 0) goto <D.45692>; else goto <D.45693>;
    <D.45692>:
    {
      struct MonoVTable * vt;

      D.45694 = cfg->domain;
      vt = mono_class_vtable (D.45694, klass);
      if (vt == 0B) goto <D.45695>; else goto <D.45696>;
      <D.45695>:
      mono_cfg_set_exception (cfg, 7);
      cfg->exception_ptr = klass;
      D.45573 = 0B;
      return D.45573;
      <D.45696>:
      {
        struct MonoInst * inst;

        D.45557 = cfg->mempool;
        inst = mono_mempool_alloc (D.45557, 80);
        inst->data.op[1].const_val = 0;
        D.45697 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.45697;
        inst->prev = 0B;
        D.45698 = inst->prev;
        inst->next = D.45698;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.45699 = inst->sreg3;
        inst->sreg2 = D.45699;
        D.45700 = inst->sreg2;
        inst->sreg1 = D.45700;
        D.45564 = cfg->ip;
        inst->cil_code = D.45564;
        inst->dreg = -1;
        inst->sreg1 = vtable_reg;
        vt.389 = (long int) vt;
        inst->data.op[1].const_val = vt.389;
        D.45568 = cfg->cbb;
        D.45569 = D.45568->last_ins;
        if (D.45569 != 0B) goto <D.45702>; else goto <D.45703>;
        <D.45702>:
        D.45568 = cfg->cbb;
        D.45569 = D.45568->last_ins;
        D.45569->next = inst;
        D.45568 = cfg->cbb;
        D.45569 = D.45568->last_ins;
        inst->prev = D.45569;
        D.45568 = cfg->cbb;
        D.45568->last_ins = inst;
        goto <D.45704>;
        <D.45703>:
        D.45568 = cfg->cbb;
        D.45568 = cfg->cbb;
        D.45568->last_ins = inst;
        D.45569 = D.45568->last_ins;
        D.45568->code = D.45569;
        <D.45704>:
      }
    }
    goto <D.45705>;
    <D.45693>:
    {
      struct MonoInst * inst;

      D.45557 = cfg->mempool;
      inst = mono_mempool_alloc (D.45557, 80);
      inst->data.op[1].const_val = 0;
      D.45706 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45706;
      inst->prev = 0B;
      D.45707 = inst->prev;
      inst->next = D.45707;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45708 = inst->sreg3;
      inst->sreg2 = D.45708;
      D.45709 = inst->sreg2;
      inst->sreg1 = D.45709;
      D.45564 = cfg->ip;
      inst->cil_code = D.45564;
      inst->dreg = klass_reg;
      inst->sreg1 = vtable_reg;
      inst->data.op[0].const_val = 0;
      D.45568 = cfg->cbb;
      D.45569 = D.45568->last_ins;
      if (D.45569 != 0B) goto <D.45710>; else goto <D.45711>;
      <D.45710>:
      D.45568 = cfg->cbb;
      D.45569 = D.45568->last_ins;
      D.45569->next = inst;
      D.45568 = cfg->cbb;
      D.45569 = D.45568->last_ins;
      inst->prev = D.45569;
      D.45568 = cfg->cbb;
      D.45568->last_ins = inst;
      goto <D.45712>;
      <D.45711>:
      D.45568 = cfg->cbb;
      D.45568 = cfg->cbb;
      D.45568->last_ins = inst;
      D.45569 = D.45568->last_ins;
      D.45568->code = D.45569;
      <D.45712>:
    }
    {
      struct MonoInst * inst;

      D.45557 = cfg->mempool;
      inst = mono_mempool_alloc (D.45557, 80);
      inst->data.op[1].const_val = 0;
      D.45713 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45713;
      inst->prev = 0B;
      D.45714 = inst->prev;
      inst->next = D.45714;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45715 = inst->sreg3;
      inst->sreg2 = D.45715;
      D.45716 = inst->sreg2;
      inst->sreg1 = D.45716;
      D.45564 = cfg->ip;
      inst->cil_code = D.45564;
      inst->dreg = -1;
      inst->sreg1 = klass_reg;
      klass.390 = (long int) klass;
      inst->data.op[1].const_val = klass.390;
      D.45568 = cfg->cbb;
      D.45569 = D.45568->last_ins;
      if (D.45569 != 0B) goto <D.45718>; else goto <D.45719>;
      <D.45718>:
      D.45568 = cfg->cbb;
      D.45569 = D.45568->last_ins;
      D.45569->next = inst;
      D.45568 = cfg->cbb;
      D.45569 = D.45568->last_ins;
      inst->prev = D.45569;
      D.45568 = cfg->cbb;
      D.45568->last_ins = inst;
      goto <D.45720>;
      <D.45719>:
      D.45568 = cfg->cbb;
      D.45568 = cfg->cbb;
      D.45568->last_ins = inst;
      D.45569 = D.45568->last_ins;
      D.45568->code = D.45569;
      <D.45720>:
    }
    <D.45705>:
    {
      struct MonoInst * inst;

      D.45557 = cfg->mempool;
      inst = mono_mempool_alloc (D.45557, 80);
      inst->data.op[1].const_val = 0;
      D.45721 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45721;
      inst->prev = 0B;
      D.45722 = inst->prev;
      inst->next = D.45722;
      inst->opcode = 456;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45723 = inst->sreg3;
      inst->sreg2 = D.45723;
      D.45724 = inst->sreg2;
      inst->sreg1 = D.45724;
      D.45564 = cfg->ip;
      inst->cil_code = D.45564;
      inst->data.op[1].p = "InvalidCastException";
      D.45568 = cfg->cbb;
      D.45569 = D.45568->last_ins;
      if (D.45569 != 0B) goto <D.45725>; else goto <D.45726>;
      <D.45725>:
      D.45568 = cfg->cbb;
      D.45569 = D.45568->last_ins;
      D.45569->next = inst;
      D.45568 = cfg->cbb;
      D.45569 = D.45568->last_ins;
      inst->prev = D.45569;
      D.45568 = cfg->cbb;
      D.45568->last_ins = inst;
      goto <D.45727>;
      <D.45726>:
      D.45568 = cfg->cbb;
      D.45568 = cfg->cbb;
      D.45568->last_ins = inst;
      D.45569 = D.45568->last_ins;
      D.45568->code = D.45569;
      <D.45727>:
    }
    goto <D.45682>;
    <D.45681>:
    {
      struct MonoInst * inst;

      D.45557 = cfg->mempool;
      inst = mono_mempool_alloc (D.45557, 80);
      inst->data.op[1].const_val = 0;
      D.45728 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45728;
      inst->prev = 0B;
      D.45729 = inst->prev;
      inst->next = D.45729;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45730 = inst->sreg3;
      inst->sreg2 = D.45730;
      D.45731 = inst->sreg2;
      inst->sreg1 = D.45731;
      D.45564 = cfg->ip;
      inst->cil_code = D.45564;
      inst->dreg = klass_reg;
      inst->sreg1 = vtable_reg;
      inst->data.op[0].const_val = 0;
      D.45568 = cfg->cbb;
      D.45569 = D.45568->last_ins;
      if (D.45569 != 0B) goto <D.45732>; else goto <D.45733>;
      <D.45732>:
      D.45568 = cfg->cbb;
      D.45569 = D.45568->last_ins;
      D.45569->next = inst;
      D.45568 = cfg->cbb;
      D.45569 = D.45568->last_ins;
      inst->prev = D.45569;
      D.45568 = cfg->cbb;
      D.45568->last_ins = inst;
      goto <D.45734>;
      <D.45733>:
      D.45568 = cfg->cbb;
      D.45568 = cfg->cbb;
      D.45568->last_ins = inst;
      D.45569 = D.45568->last_ins;
      D.45568->code = D.45569;
      <D.45734>:
    }
    mini_emit_castclass_inst (cfg, obj_reg, klass_reg, klass, klass_inst, is_null_bb);
    <D.45682>:
  }
  <D.45672>:
  D.45735 = is_null_bb->cil_code;
  if (D.45735 != 0B) goto <D.45736>; else goto <D.45737>;
  <D.45736>:
  D.45600 = cfg->cil_offset_to_bb;
  D.45735 = is_null_bb->cil_code;
  D.45738 = (long int) D.45735;
  D.45602 = cfg->cil_start;
  D.45603 = (long int) D.45602;
  D.45739 = D.45738 - D.45603;
  D.45740 = (long unsigned int) D.45739;
  D.45741 = D.45740 * 8;
  D.45742 = D.45600 + D.45741;
  *D.45742 = is_null_bb;
  <D.45737>:
  D.45608 = cfg->real_offset;
  is_null_bb->real_offset = D.45608;
  D.45568 = cfg->cbb;
  D.45569 = D.45568->last_ins;
  if (D.45569 != 0B) goto <D.45746>; else goto <D.45743>;
  <D.45746>:
  D.45568 = cfg->cbb;
  D.45569 = D.45568->last_ins;
  D.45613 = D.45569->opcode;
  D.45614 = D.45613 + 64985;
  if (D.45614 <= 9) goto <D.45744>; else goto <D.45747>;
  <D.45747>:
  D.45568 = cfg->cbb;
  D.45569 = D.45568->last_ins;
  D.45613 = D.45569->opcode;
  D.45616 = D.45613 + 64878;
  if (D.45616 <= 9) goto <D.45744>; else goto <D.45748>;
  <D.45748>:
  D.45568 = cfg->cbb;
  D.45569 = D.45568->last_ins;
  D.45613 = D.45569->opcode;
  D.45618 = D.45613 + 64888;
  if (D.45618 <= 9) goto <D.45744>; else goto <D.45743>;
  <D.45744>:
  D.45568 = cfg->cbb;
  D.45569 = D.45568->last_ins;
  D.45619 = D.45569->data.op[1].many_blocks;
  D.45620 = D.45619 + 8;
  D.45621 = *D.45620;
  if (D.45621 == 0B) goto <D.45749>; else goto <D.45743>;
  <D.45749>:
  D.45568 = cfg->cbb;
  D.45569 = D.45568->last_ins;
  D.45619 = D.45569->data.op[1].many_blocks;
  D.45620 = D.45619 + 8;
  *D.45620 = is_null_bb;
  D.45568 = cfg->cbb;
  mono_link_bblock (cfg, D.45568, is_null_bb);
  goto <D.45745>;
  <D.45743>:
  D.45568 = cfg->cbb;
  D.45569 = D.45568->last_ins;
  if (D.45569 == 0B) goto <D.45750>; else goto <D.45752>;
  <D.45752>:
  D.45568 = cfg->cbb;
  D.45569 = D.45568->last_ins;
  D.45613 = D.45569->opcode;
  if (D.45613 != 442) goto <D.45753>; else goto <D.45751>;
  <D.45753>:
  D.45568 = cfg->cbb;
  D.45569 = D.45568->last_ins;
  D.45613 = D.45569->opcode;
  if (D.45613 != 759) goto <D.45754>; else goto <D.45751>;
  <D.45754>:
  D.45568 = cfg->cbb;
  D.45569 = D.45568->last_ins;
  D.45613 = D.45569->opcode;
  D.45614 = D.45613 + 64985;
  if (D.45614 > 9) goto <D.45755>; else goto <D.45751>;
  <D.45755>:
  D.45568 = cfg->cbb;
  D.45569 = D.45568->last_ins;
  D.45613 = D.45569->opcode;
  D.45616 = D.45613 + 64878;
  if (D.45616 > 9) goto <D.45756>; else goto <D.45751>;
  <D.45756>:
  D.45568 = cfg->cbb;
  D.45569 = D.45568->last_ins;
  D.45613 = D.45569->opcode;
  D.45618 = D.45613 + 64888;
  if (D.45618 > 9) goto <D.45750>; else goto <D.45751>;
  <D.45750>:
  D.45568 = cfg->cbb;
  mono_link_bblock (cfg, D.45568, is_null_bb);
  <D.45751>:
  <D.45745>:
  D.45568 = cfg->cbb;
  D.45568->next_bb = is_null_bb;
  cfg->cbb = is_null_bb;
  reset_cast_details (cfg);
  D.45573 = src;
  return D.45573;
}


mini_emit_castclass_inst (struct MonoCompile * cfg, int obj_reg, int klass_reg, struct MonoClass * klass, struct MonoInst * klass_inst, struct MonoBasicBlock * object_is_null)
{
  unsigned char D.45760;
  unsigned int D.45763;
  unsigned int D.45764;
  _Bool D.45765;
  long int D.45766;
  long int D.45767;
  struct MonoMemPool * D.45770;
  long int D.45771;
  struct MonoInst * D.45772;
  int D.45773;
  int D.45774;
  const unsigned char * D.45775;
  struct MonoBasicBlock * D.45776;
  struct MonoInst * D.45777;
  long int D.45781;
  struct MonoInst * D.45782;
  int D.45783;
  int D.45784;
  long int D.45785;
  long int D.45789;
  struct MonoInst * D.45790;
  int D.45791;
  int D.45792;
  long int D.45796;
  struct MonoInst * D.45797;
  int D.45798;
  int D.45799;
  struct MonoClass * D.45803;
  struct MonoClass * D.45804;
  unsigned int D.45807;
  long int D.45808;
  struct MonoInst * D.45809;
  int D.45810;
  int D.45811;
  struct MonoClass * D.45815;
  struct MonoClass * D.45816;
  unsigned int D.45824;
  unsigned int D.45825;
  unsigned char D.45831;
  unsigned int D.45836;
  long int D.45837;
  struct MonoInst * D.45838;
  int D.45839;
  int D.45840;
  long int D.45844;
  struct MonoInst * D.45845;
  int D.45846;
  int D.45847;
  long int D.45851;
  struct MonoInst * D.45852;
  int D.45853;
  int D.45854;
  unsigned int D.45859;
  unsigned int D.45860;
  unsigned int D.45861;
  short unsigned int D.45862;
  long int D.45865;
  struct MonoInst * D.45866;
  int D.45867;
  int D.45868;
  long int D.45872;
  struct MonoInst * D.45873;
  int D.45874;
  int D.45875;
  long int D.45876;
  long int D.45880;
  struct MonoInst * D.45881;
  int D.45882;
  int D.45883;
  long int D.45887;
  struct MonoInst * D.45888;
  int D.45889;
  int D.45890;
  long int D.45894;
  struct MonoInst * D.45895;
  int D.45896;
  int D.45897;
  int D.45898;
  int D.45899;
  int D.45900;
  long int D.45901;

  D.45760 = klass->rank;
  if (D.45760 != 0) goto <D.45761>; else goto <D.45762>;
  <D.45761>:
  {
    int rank_reg;
    int eclass_reg;

    D.45763 = alloc_preg (cfg);
    rank_reg = (int) D.45763;
    D.45764 = alloc_preg (cfg);
    eclass_reg = (int) D.45764;
    D.45765 = klass_inst != 0B;
    D.45766 = (long int) D.45765;
    D.45767 = __builtin_expect (D.45766, 0);
    if (D.45767 != 0) goto <D.45768>; else goto <D.45769>;
    <D.45768>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1685, "!klass_inst");
    <D.45769>:
    {
      struct MonoInst * inst;

      D.45770 = cfg->mempool;
      inst = mono_mempool_alloc (D.45770, 80);
      inst->data.op[1].const_val = 0;
      D.45771 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45771;
      inst->prev = 0B;
      D.45772 = inst->prev;
      inst->next = D.45772;
      inst->opcode = 390;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45773 = inst->sreg3;
      inst->sreg2 = D.45773;
      D.45774 = inst->sreg2;
      inst->sreg1 = D.45774;
      D.45775 = cfg->ip;
      inst->cil_code = D.45775;
      inst->dreg = rank_reg;
      inst->sreg1 = klass_reg;
      inst->data.op[0].const_val = 26;
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      if (D.45777 != 0B) goto <D.45778>; else goto <D.45779>;
      <D.45778>:
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      D.45777->next = inst;
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      inst->prev = D.45777;
      D.45776 = cfg->cbb;
      D.45776->last_ins = inst;
      goto <D.45780>;
      <D.45779>:
      D.45776 = cfg->cbb;
      D.45776 = cfg->cbb;
      D.45776->last_ins = inst;
      D.45777 = D.45776->last_ins;
      D.45776->code = D.45777;
      <D.45780>:
    }
    {
      struct MonoInst * inst;

      D.45770 = cfg->mempool;
      inst = mono_mempool_alloc (D.45770, 80);
      inst->data.op[1].const_val = 0;
      D.45781 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45781;
      inst->prev = 0B;
      D.45782 = inst->prev;
      inst->next = D.45782;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45783 = inst->sreg3;
      inst->sreg2 = D.45783;
      D.45784 = inst->sreg2;
      inst->sreg1 = D.45784;
      D.45775 = cfg->ip;
      inst->cil_code = D.45775;
      inst->dreg = -1;
      inst->sreg1 = rank_reg;
      D.45760 = klass->rank;
      D.45785 = (long int) D.45760;
      inst->data.op[1].const_val = D.45785;
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      if (D.45777 != 0B) goto <D.45786>; else goto <D.45787>;
      <D.45786>:
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      D.45777->next = inst;
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      inst->prev = D.45777;
      D.45776 = cfg->cbb;
      D.45776->last_ins = inst;
      goto <D.45788>;
      <D.45787>:
      D.45776 = cfg->cbb;
      D.45776 = cfg->cbb;
      D.45776->last_ins = inst;
      D.45777 = D.45776->last_ins;
      D.45776->code = D.45777;
      <D.45788>:
    }
    {
      struct MonoInst * inst;

      D.45770 = cfg->mempool;
      inst = mono_mempool_alloc (D.45770, 80);
      inst->data.op[1].const_val = 0;
      D.45789 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45789;
      inst->prev = 0B;
      D.45790 = inst->prev;
      inst->next = D.45790;
      inst->opcode = 456;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45791 = inst->sreg3;
      inst->sreg2 = D.45791;
      D.45792 = inst->sreg2;
      inst->sreg1 = D.45792;
      D.45775 = cfg->ip;
      inst->cil_code = D.45775;
      inst->data.op[1].p = "InvalidCastException";
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      if (D.45777 != 0B) goto <D.45793>; else goto <D.45794>;
      <D.45793>:
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      D.45777->next = inst;
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      inst->prev = D.45777;
      D.45776 = cfg->cbb;
      D.45776->last_ins = inst;
      goto <D.45795>;
      <D.45794>:
      D.45776 = cfg->cbb;
      D.45776 = cfg->cbb;
      D.45776->last_ins = inst;
      D.45777 = D.45776->last_ins;
      D.45776->code = D.45777;
      <D.45795>:
    }
    {
      struct MonoInst * inst;

      D.45770 = cfg->mempool;
      inst = mono_mempool_alloc (D.45770, 80);
      inst->data.op[1].const_val = 0;
      D.45796 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45796;
      inst->prev = 0B;
      D.45797 = inst->prev;
      inst->next = D.45797;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45798 = inst->sreg3;
      inst->sreg2 = D.45798;
      D.45799 = inst->sreg2;
      inst->sreg1 = D.45799;
      D.45775 = cfg->ip;
      inst->cil_code = D.45775;
      inst->dreg = eclass_reg;
      inst->sreg1 = klass_reg;
      inst->data.op[0].const_val = 8;
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      if (D.45777 != 0B) goto <D.45800>; else goto <D.45801>;
      <D.45800>:
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      D.45777->next = inst;
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      inst->prev = D.45777;
      D.45776 = cfg->cbb;
      D.45776->last_ins = inst;
      goto <D.45802>;
      <D.45801>:
      D.45776 = cfg->cbb;
      D.45776 = cfg->cbb;
      D.45776->last_ins = inst;
      D.45777 = D.45776->last_ins;
      D.45776->code = D.45777;
      <D.45802>:
    }
    D.45803 = klass->cast_class;
    D.45804 = mono_defaults.object_class;
    if (D.45803 == D.45804) goto <D.45805>; else goto <D.45806>;
    <D.45805>:
    {
      int parent_reg;

      D.45807 = alloc_preg (cfg);
      parent_reg = (int) D.45807;
      {
        struct MonoInst * inst;

        D.45770 = cfg->mempool;
        inst = mono_mempool_alloc (D.45770, 80);
        inst->data.op[1].const_val = 0;
        D.45808 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.45808;
        inst->prev = 0B;
        D.45809 = inst->prev;
        inst->next = D.45809;
        inst->opcode = 388;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.45810 = inst->sreg3;
        inst->sreg2 = D.45810;
        D.45811 = inst->sreg2;
        inst->sreg1 = D.45811;
        D.45775 = cfg->ip;
        inst->cil_code = D.45775;
        inst->dreg = parent_reg;
        inst->sreg1 = eclass_reg;
        inst->data.op[0].const_val = 40;
        D.45776 = cfg->cbb;
        D.45777 = D.45776->last_ins;
        if (D.45777 != 0B) goto <D.45812>; else goto <D.45813>;
        <D.45812>:
        D.45776 = cfg->cbb;
        D.45777 = D.45776->last_ins;
        D.45777->next = inst;
        D.45776 = cfg->cbb;
        D.45777 = D.45776->last_ins;
        inst->prev = D.45777;
        D.45776 = cfg->cbb;
        D.45776->last_ins = inst;
        goto <D.45814>;
        <D.45813>:
        D.45776 = cfg->cbb;
        D.45776 = cfg->cbb;
        D.45776->last_ins = inst;
        D.45777 = D.45776->last_ins;
        D.45776->code = D.45777;
        <D.45814>:
      }
      D.45815 = mono_defaults.enum_class;
      D.45816 = D.45815->parent;
      mini_emit_class_check_branch (cfg, parent_reg, D.45816, 556, object_is_null);
      D.45815 = mono_defaults.enum_class;
      mini_emit_class_check (cfg, eclass_reg, D.45815);
    }
    goto <D.45817>;
    <D.45806>:
    D.45803 = klass->cast_class;
    D.45815 = mono_defaults.enum_class;
    D.45816 = D.45815->parent;
    if (D.45803 == D.45816) goto <D.45818>; else goto <D.45819>;
    <D.45818>:
    D.45815 = mono_defaults.enum_class;
    D.45816 = D.45815->parent;
    mini_emit_class_check_branch (cfg, eclass_reg, D.45816, 551, object_is_null);
    D.45815 = mono_defaults.enum_class;
    mini_emit_class_check (cfg, eclass_reg, D.45815);
    goto <D.45820>;
    <D.45819>:
    D.45803 = klass->cast_class;
    D.45815 = mono_defaults.enum_class;
    if (D.45803 == D.45815) goto <D.45821>; else goto <D.45822>;
    <D.45821>:
    D.45815 = mono_defaults.enum_class;
    mini_emit_class_check (cfg, eclass_reg, D.45815);
    goto <D.45823>;
    <D.45822>:
    D.45803 = klass->cast_class;
    D.45824 = D.45803->flags;
    D.45825 = D.45824 & 32;
    if (D.45825 != 0) goto <D.45826>; else goto <D.45827>;
    <D.45826>:
    D.45803 = klass->cast_class;
    mini_emit_iface_class_cast (cfg, eclass_reg, D.45803, 0B, 0B);
    goto <D.45828>;
    <D.45827>:
    D.45803 = klass->cast_class;
    mini_emit_castclass (cfg, -1, eclass_reg, D.45803, object_is_null);
    <D.45828>:
    <D.45823>:
    <D.45820>:
    <D.45817>:
    D.45760 = klass->rank;
    if (D.45760 == 1) goto <D.45829>; else goto <D.45830>;
    <D.45829>:
    D.45831 = klass->byval_arg.type;
    if (D.45831 == 29) goto <D.45832>; else goto <D.45833>;
    <D.45832>:
    if (obj_reg != -1) goto <D.45834>; else goto <D.45835>;
    <D.45834>:
    {
      int bounds_reg;

      D.45836 = alloc_preg (cfg);
      bounds_reg = (int) D.45836;
      {
        struct MonoInst * inst;

        D.45770 = cfg->mempool;
        inst = mono_mempool_alloc (D.45770, 80);
        inst->data.op[1].const_val = 0;
        D.45837 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.45837;
        inst->prev = 0B;
        D.45838 = inst->prev;
        inst->next = D.45838;
        inst->opcode = 388;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.45839 = inst->sreg3;
        inst->sreg2 = D.45839;
        D.45840 = inst->sreg2;
        inst->sreg1 = D.45840;
        D.45775 = cfg->ip;
        inst->cil_code = D.45775;
        inst->dreg = bounds_reg;
        inst->sreg1 = obj_reg;
        inst->data.op[0].const_val = 16;
        D.45776 = cfg->cbb;
        D.45777 = D.45776->last_ins;
        if (D.45777 != 0B) goto <D.45841>; else goto <D.45842>;
        <D.45841>:
        D.45776 = cfg->cbb;
        D.45777 = D.45776->last_ins;
        D.45777->next = inst;
        D.45776 = cfg->cbb;
        D.45777 = D.45776->last_ins;
        inst->prev = D.45777;
        D.45776 = cfg->cbb;
        D.45776->last_ins = inst;
        goto <D.45843>;
        <D.45842>:
        D.45776 = cfg->cbb;
        D.45776 = cfg->cbb;
        D.45776->last_ins = inst;
        D.45777 = D.45776->last_ins;
        D.45776->code = D.45777;
        <D.45843>:
      }
      {
        struct MonoInst * inst;

        D.45770 = cfg->mempool;
        inst = mono_mempool_alloc (D.45770, 80);
        inst->data.op[1].const_val = 0;
        D.45844 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.45844;
        inst->prev = 0B;
        D.45845 = inst->prev;
        inst->next = D.45845;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.45846 = inst->sreg3;
        inst->sreg2 = D.45846;
        D.45847 = inst->sreg2;
        inst->sreg1 = D.45847;
        D.45775 = cfg->ip;
        inst->cil_code = D.45775;
        inst->dreg = -1;
        inst->sreg1 = bounds_reg;
        inst->data.op[1].const_val = 0;
        D.45776 = cfg->cbb;
        D.45777 = D.45776->last_ins;
        if (D.45777 != 0B) goto <D.45848>; else goto <D.45849>;
        <D.45848>:
        D.45776 = cfg->cbb;
        D.45777 = D.45776->last_ins;
        D.45777->next = inst;
        D.45776 = cfg->cbb;
        D.45777 = D.45776->last_ins;
        inst->prev = D.45777;
        D.45776 = cfg->cbb;
        D.45776->last_ins = inst;
        goto <D.45850>;
        <D.45849>:
        D.45776 = cfg->cbb;
        D.45776 = cfg->cbb;
        D.45776->last_ins = inst;
        D.45777 = D.45776->last_ins;
        D.45776->code = D.45777;
        <D.45850>:
      }
      {
        struct MonoInst * inst;

        D.45770 = cfg->mempool;
        inst = mono_mempool_alloc (D.45770, 80);
        inst->data.op[1].const_val = 0;
        D.45851 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.45851;
        inst->prev = 0B;
        D.45852 = inst->prev;
        inst->next = D.45852;
        inst->opcode = 456;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.45853 = inst->sreg3;
        inst->sreg2 = D.45853;
        D.45854 = inst->sreg2;
        inst->sreg1 = D.45854;
        D.45775 = cfg->ip;
        inst->cil_code = D.45775;
        inst->data.op[1].p = "InvalidCastException";
        D.45776 = cfg->cbb;
        D.45777 = D.45776->last_ins;
        if (D.45777 != 0B) goto <D.45855>; else goto <D.45856>;
        <D.45855>:
        D.45776 = cfg->cbb;
        D.45777 = D.45776->last_ins;
        D.45777->next = inst;
        D.45776 = cfg->cbb;
        D.45777 = D.45776->last_ins;
        inst->prev = D.45777;
        D.45776 = cfg->cbb;
        D.45776->last_ins = inst;
        goto <D.45857>;
        <D.45856>:
        D.45776 = cfg->cbb;
        D.45776 = cfg->cbb;
        D.45776->last_ins = inst;
        D.45777 = D.45776->last_ins;
        D.45776->code = D.45777;
        <D.45857>:
      }
    }
    <D.45835>:
    <D.45833>:
    <D.45830>:
  }
  goto <D.45858>;
  <D.45762>:
  {
    int idepth_reg;
    int stypes_reg;
    int stype;

    D.45859 = alloc_preg (cfg);
    idepth_reg = (int) D.45859;
    D.45860 = alloc_preg (cfg);
    stypes_reg = (int) D.45860;
    D.45861 = alloc_preg (cfg);
    stype = (int) D.45861;
    mono_class_setup_supertypes (klass);
    D.45862 = klass->idepth;
    if (D.45862 > 6) goto <D.45863>; else goto <D.45864>;
    <D.45863>:
    {
      struct MonoInst * inst;

      D.45770 = cfg->mempool;
      inst = mono_mempool_alloc (D.45770, 80);
      inst->data.op[1].const_val = 0;
      D.45865 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45865;
      inst->prev = 0B;
      D.45866 = inst->prev;
      inst->next = D.45866;
      inst->opcode = 392;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45867 = inst->sreg3;
      inst->sreg2 = D.45867;
      D.45868 = inst->sreg2;
      inst->sreg1 = D.45868;
      D.45775 = cfg->ip;
      inst->cil_code = D.45775;
      inst->dreg = idepth_reg;
      inst->sreg1 = klass_reg;
      inst->data.op[0].const_val = 24;
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      if (D.45777 != 0B) goto <D.45869>; else goto <D.45870>;
      <D.45869>:
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      D.45777->next = inst;
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      inst->prev = D.45777;
      D.45776 = cfg->cbb;
      D.45776->last_ins = inst;
      goto <D.45871>;
      <D.45870>:
      D.45776 = cfg->cbb;
      D.45776 = cfg->cbb;
      D.45776->last_ins = inst;
      D.45777 = D.45776->last_ins;
      D.45776->code = D.45777;
      <D.45871>:
    }
    {
      struct MonoInst * inst;

      D.45770 = cfg->mempool;
      inst = mono_mempool_alloc (D.45770, 80);
      inst->data.op[1].const_val = 0;
      D.45872 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45872;
      inst->prev = 0B;
      D.45873 = inst->prev;
      inst->next = D.45873;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45874 = inst->sreg3;
      inst->sreg2 = D.45874;
      D.45875 = inst->sreg2;
      inst->sreg1 = D.45875;
      D.45775 = cfg->ip;
      inst->cil_code = D.45775;
      inst->dreg = -1;
      inst->sreg1 = idepth_reg;
      D.45862 = klass->idepth;
      D.45876 = (long int) D.45862;
      inst->data.op[1].const_val = D.45876;
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      if (D.45777 != 0B) goto <D.45877>; else goto <D.45878>;
      <D.45877>:
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      D.45777->next = inst;
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      inst->prev = D.45777;
      D.45776 = cfg->cbb;
      D.45776->last_ins = inst;
      goto <D.45879>;
      <D.45878>:
      D.45776 = cfg->cbb;
      D.45776 = cfg->cbb;
      D.45776->last_ins = inst;
      D.45777 = D.45776->last_ins;
      D.45776->code = D.45777;
      <D.45879>:
    }
    {
      struct MonoInst * inst;

      D.45770 = cfg->mempool;
      inst = mono_mempool_alloc (D.45770, 80);
      inst->data.op[1].const_val = 0;
      D.45880 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45880;
      inst->prev = 0B;
      D.45881 = inst->prev;
      inst->next = D.45881;
      inst->opcode = 460;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45882 = inst->sreg3;
      inst->sreg2 = D.45882;
      D.45883 = inst->sreg2;
      inst->sreg1 = D.45883;
      D.45775 = cfg->ip;
      inst->cil_code = D.45775;
      inst->data.op[1].p = "InvalidCastException";
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      if (D.45777 != 0B) goto <D.45884>; else goto <D.45885>;
      <D.45884>:
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      D.45777->next = inst;
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      inst->prev = D.45777;
      D.45776 = cfg->cbb;
      D.45776->last_ins = inst;
      goto <D.45886>;
      <D.45885>:
      D.45776 = cfg->cbb;
      D.45776 = cfg->cbb;
      D.45776->last_ins = inst;
      D.45777 = D.45776->last_ins;
      D.45776->code = D.45777;
      <D.45886>:
    }
    <D.45864>:
    {
      struct MonoInst * inst;

      D.45770 = cfg->mempool;
      inst = mono_mempool_alloc (D.45770, 80);
      inst->data.op[1].const_val = 0;
      D.45887 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45887;
      inst->prev = 0B;
      D.45888 = inst->prev;
      inst->next = D.45888;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45889 = inst->sreg3;
      inst->sreg2 = D.45889;
      D.45890 = inst->sreg2;
      inst->sreg1 = D.45890;
      D.45775 = cfg->ip;
      inst->cil_code = D.45775;
      inst->dreg = stypes_reg;
      inst->sreg1 = klass_reg;
      inst->data.op[0].const_val = 16;
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      if (D.45777 != 0B) goto <D.45891>; else goto <D.45892>;
      <D.45891>:
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      D.45777->next = inst;
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      inst->prev = D.45777;
      D.45776 = cfg->cbb;
      D.45776->last_ins = inst;
      goto <D.45893>;
      <D.45892>:
      D.45776 = cfg->cbb;
      D.45776 = cfg->cbb;
      D.45776->last_ins = inst;
      D.45777 = D.45776->last_ins;
      D.45776->code = D.45777;
      <D.45893>:
    }
    {
      struct MonoInst * inst;

      D.45770 = cfg->mempool;
      inst = mono_mempool_alloc (D.45770, 80);
      inst->data.op[1].const_val = 0;
      D.45894 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45894;
      inst->prev = 0B;
      D.45895 = inst->prev;
      inst->next = D.45895;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45896 = inst->sreg3;
      inst->sreg2 = D.45896;
      D.45897 = inst->sreg2;
      inst->sreg1 = D.45897;
      D.45775 = cfg->ip;
      inst->cil_code = D.45775;
      inst->dreg = stype;
      inst->sreg1 = stypes_reg;
      D.45862 = klass->idepth;
      D.45898 = (int) D.45862;
      D.45899 = D.45898 + -1;
      D.45900 = D.45899 * 8;
      D.45901 = (long int) D.45900;
      inst->data.op[0].const_val = D.45901;
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      if (D.45777 != 0B) goto <D.45902>; else goto <D.45903>;
      <D.45902>:
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      D.45777->next = inst;
      D.45776 = cfg->cbb;
      D.45777 = D.45776->last_ins;
      inst->prev = D.45777;
      D.45776 = cfg->cbb;
      D.45776->last_ins = inst;
      goto <D.45904>;
      <D.45903>:
      D.45776 = cfg->cbb;
      D.45776 = cfg->cbb;
      D.45776->last_ins = inst;
      D.45777 = D.45776->last_ins;
      D.45776->code = D.45777;
      <D.45904>:
    }
    mini_emit_class_check_inst (cfg, stype, klass, klass_inst);
  }
  <D.45858>:
}


mini_emit_castclass (struct MonoCompile * cfg, int obj_reg, int klass_reg, struct MonoClass * klass, struct MonoBasicBlock * object_is_null)
{
  mini_emit_castclass_inst (cfg, obj_reg, klass_reg, klass, 0B, object_is_null);
}


mini_emit_class_check_inst (struct MonoCompile * cfg, int klass_reg, struct MonoClass * klass, struct MonoInst * klass_inst)
{
  struct MonoMemPool * D.45907;
  long int D.45908;
  struct MonoInst * D.45909;
  int D.45910;
  int D.45911;
  const unsigned char * D.45912;
  int D.45913;
  struct MonoBasicBlock * D.45914;
  struct MonoInst * D.45915;
  long unsigned int D.45920;
  long unsigned int D.45921;
  unsigned int D.45924;
  long int D.45925;
  struct MonoInst * D.45926;
  guint16 iftmp.391;
  int D.45931;
  int D.45932;
  long int D.45936;
  struct MonoInst * D.45937;
  int D.45938;
  int D.45939;
  long int D.45944;
  struct MonoInst * D.45945;
  int D.45946;
  int D.45947;
  long int klass.392;
  long int D.45952;
  struct MonoInst * D.45953;
  int D.45954;
  int D.45955;

  if (klass_inst != 0B) goto <D.45905>; else goto <D.45906>;
  <D.45905>:
  {
    struct MonoInst * inst;

    D.45907 = cfg->mempool;
    inst = mono_mempool_alloc (D.45907, 80);
    inst->data.op[1].const_val = 0;
    D.45908 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.45908;
    inst->prev = 0B;
    D.45909 = inst->prev;
    inst->next = D.45909;
    inst->opcode = 322;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.45910 = inst->sreg3;
    inst->sreg2 = D.45910;
    D.45911 = inst->sreg2;
    inst->sreg1 = D.45911;
    D.45912 = cfg->ip;
    inst->cil_code = D.45912;
    inst->dreg = -1;
    inst->sreg1 = klass_reg;
    D.45913 = klass_inst->dreg;
    inst->sreg2 = D.45913;
    D.45914 = cfg->cbb;
    D.45915 = D.45914->last_ins;
    if (D.45915 != 0B) goto <D.45916>; else goto <D.45917>;
    <D.45916>:
    D.45914 = cfg->cbb;
    D.45915 = D.45914->last_ins;
    D.45915->next = inst;
    D.45914 = cfg->cbb;
    D.45915 = D.45914->last_ins;
    inst->prev = D.45915;
    D.45914 = cfg->cbb;
    D.45914->last_ins = inst;
    goto <D.45918>;
    <D.45917>:
    D.45914 = cfg->cbb;
    D.45914 = cfg->cbb;
    D.45914->last_ins = inst;
    D.45915 = D.45914->last_ins;
    D.45914->code = D.45915;
    <D.45918>:
  }
  goto <D.45919>;
  <D.45906>:
  D.45920 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.45921 = D.45920 & 33554432;
  if (D.45921 != 0) goto <D.45922>; else goto <D.45923>;
  <D.45922>:
  {
    int const_reg;

    D.45924 = alloc_preg (cfg);
    const_reg = (int) D.45924;
    {
      struct MonoInst * inst;

      D.45907 = cfg->mempool;
      inst = mono_mempool_alloc (D.45907, 80);
      inst->data.op[1].const_val = 0;
      D.45925 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45925;
      inst->prev = 0B;
      D.45926 = inst->prev;
      inst->next = D.45926;
      D.45920 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.45921 = D.45920 & 33554432;
      if (D.45921 != 0) goto <D.45928>; else goto <D.45929>;
      <D.45928>:
      iftmp.391 = 732;
      goto <D.45930>;
      <D.45929>:
      iftmp.391 = 363;
      <D.45930>:
      inst->opcode = iftmp.391;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45931 = inst->sreg3;
      inst->sreg2 = D.45931;
      D.45932 = inst->sreg2;
      inst->sreg1 = D.45932;
      D.45912 = cfg->ip;
      inst->cil_code = D.45912;
      inst->dreg = const_reg;
      inst->data.op[0].p = klass;
      inst->data.op[1].const_val = 11;
      D.45914 = cfg->cbb;
      D.45915 = D.45914->last_ins;
      if (D.45915 != 0B) goto <D.45933>; else goto <D.45934>;
      <D.45933>:
      D.45914 = cfg->cbb;
      D.45915 = D.45914->last_ins;
      D.45915->next = inst;
      D.45914 = cfg->cbb;
      D.45915 = D.45914->last_ins;
      inst->prev = D.45915;
      D.45914 = cfg->cbb;
      D.45914->last_ins = inst;
      goto <D.45935>;
      <D.45934>:
      D.45914 = cfg->cbb;
      D.45914 = cfg->cbb;
      D.45914->last_ins = inst;
      D.45915 = D.45914->last_ins;
      D.45914->code = D.45915;
      <D.45935>:
    }
    {
      struct MonoInst * inst;

      D.45907 = cfg->mempool;
      inst = mono_mempool_alloc (D.45907, 80);
      inst->data.op[1].const_val = 0;
      D.45936 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.45936;
      inst->prev = 0B;
      D.45937 = inst->prev;
      inst->next = D.45937;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.45938 = inst->sreg3;
      inst->sreg2 = D.45938;
      D.45939 = inst->sreg2;
      inst->sreg1 = D.45939;
      D.45912 = cfg->ip;
      inst->cil_code = D.45912;
      inst->dreg = -1;
      inst->sreg1 = klass_reg;
      inst->sreg2 = const_reg;
      D.45914 = cfg->cbb;
      D.45915 = D.45914->last_ins;
      if (D.45915 != 0B) goto <D.45940>; else goto <D.45941>;
      <D.45940>:
      D.45914 = cfg->cbb;
      D.45915 = D.45914->last_ins;
      D.45915->next = inst;
      D.45914 = cfg->cbb;
      D.45915 = D.45914->last_ins;
      inst->prev = D.45915;
      D.45914 = cfg->cbb;
      D.45914->last_ins = inst;
      goto <D.45942>;
      <D.45941>:
      D.45914 = cfg->cbb;
      D.45914 = cfg->cbb;
      D.45914->last_ins = inst;
      D.45915 = D.45914->last_ins;
      D.45914->code = D.45915;
      <D.45942>:
    }
  }
  goto <D.45943>;
  <D.45923>:
  {
    struct MonoInst * inst;

    D.45907 = cfg->mempool;
    inst = mono_mempool_alloc (D.45907, 80);
    inst->data.op[1].const_val = 0;
    D.45944 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.45944;
    inst->prev = 0B;
    D.45945 = inst->prev;
    inst->next = D.45945;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.45946 = inst->sreg3;
    inst->sreg2 = D.45946;
    D.45947 = inst->sreg2;
    inst->sreg1 = D.45947;
    D.45912 = cfg->ip;
    inst->cil_code = D.45912;
    inst->dreg = -1;
    inst->sreg1 = klass_reg;
    klass.392 = (long int) klass;
    inst->data.op[1].const_val = klass.392;
    D.45914 = cfg->cbb;
    D.45915 = D.45914->last_ins;
    if (D.45915 != 0B) goto <D.45949>; else goto <D.45950>;
    <D.45949>:
    D.45914 = cfg->cbb;
    D.45915 = D.45914->last_ins;
    D.45915->next = inst;
    D.45914 = cfg->cbb;
    D.45915 = D.45914->last_ins;
    inst->prev = D.45915;
    D.45914 = cfg->cbb;
    D.45914->last_ins = inst;
    goto <D.45951>;
    <D.45950>:
    D.45914 = cfg->cbb;
    D.45914 = cfg->cbb;
    D.45914->last_ins = inst;
    D.45915 = D.45914->last_ins;
    D.45914->code = D.45915;
    <D.45951>:
  }
  <D.45943>:
  <D.45919>:
  {
    struct MonoInst * inst;

    D.45907 = cfg->mempool;
    inst = mono_mempool_alloc (D.45907, 80);
    inst->data.op[1].const_val = 0;
    D.45952 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.45952;
    inst->prev = 0B;
    D.45953 = inst->prev;
    inst->next = D.45953;
    inst->opcode = 456;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.45954 = inst->sreg3;
    inst->sreg2 = D.45954;
    D.45955 = inst->sreg2;
    inst->sreg1 = D.45955;
    D.45912 = cfg->ip;
    inst->cil_code = D.45912;
    inst->data.op[1].p = "InvalidCastException";
    D.45914 = cfg->cbb;
    D.45915 = D.45914->last_ins;
    if (D.45915 != 0B) goto <D.45956>; else goto <D.45957>;
    <D.45956>:
    D.45914 = cfg->cbb;
    D.45915 = D.45914->last_ins;
    D.45915->next = inst;
    D.45914 = cfg->cbb;
    D.45915 = D.45914->last_ins;
    inst->prev = D.45915;
    D.45914 = cfg->cbb;
    D.45914->last_ins = inst;
    goto <D.45958>;
    <D.45957>:
    D.45914 = cfg->cbb;
    D.45914 = cfg->cbb;
    D.45914->last_ins = inst;
    D.45915 = D.45914->last_ins;
    D.45914->code = D.45915;
    <D.45958>:
  }
}


handle_stack_args (struct MonoCompile * cfg, struct MonoInst * * sp, int count)
{
  unsigned int D.45961;
  int D.45964;
  short unsigned int D.45965;
  short unsigned int D.45968;
  struct MonoBasicBlock * * D.45969;
  long unsigned int D.45970;
  long unsigned int D.45971;
  struct MonoBasicBlock * * D.45972;
  unsigned int D.45973;
  unsigned int D.45974;
  struct MonoInst * * D.45977;
  short int D.45980;
  int D.45981;
  struct MonoMemPool * D.45984;
  long unsigned int D.45985;
  unsigned int D.45986;
  unsigned int D.45987;
  void * D.45988;
  struct MonoMethod * D.45989;
  struct MonoInst * * D.45992;
  struct MonoInst * * D.45993;
  struct MonoInst * * D.45994;
  struct MonoInst * D.45995;
  struct MonoType * D.45996;
  struct MonoInst * D.45997;
  struct MonoInst * D.45999;
  short unsigned int D.46002;
  long int D.46007;
  struct MonoInst * D.46008;
  int D.46009;
  int D.46010;
  const unsigned char * D.46011;
  struct MonoInst * * D.46012;
  struct MonoInst * * D.46013;
  struct MonoInst * D.46014;
  long int D.46015;
  long unsigned int D.46016;
  long unsigned int D.46017;
  struct MonoInst * * D.46018;
  struct MonoInst * D.46019;
  struct MonoType * D.46020;
  unsigned int D.46021;
  short unsigned int D.46022;
  struct MonoClass * D.46023;
  int D.46024;
  int D.46025;
  short unsigned int D.46026;
  struct MonoClass * D.46029;
  struct MonoBasicBlock * D.46030;
  struct MonoInst * D.46031;
  const unsigned char * D.46035;
  int D.46038;
  long unsigned int D.46039;
  long unsigned int D.46040;
  struct MonoBasicBlock * * D.46041;
  struct MonoInst * * D.46046;
  struct MonoInst * D.46047;
  long int D.46048;
  long unsigned int D.46049;
  long unsigned int D.46050;
  struct MonoInst * * D.46051;
  struct MonoInst * D.46052;
  struct MonoType * D.46053;
  unsigned int D.46054;
  short unsigned int D.46055;
  struct MonoClass * D.46056;
  int D.46057;
  struct MonoClass * D.46060;
  int D.46066;
  int i;
  int bindex;
  struct MonoBasicBlock * bb;
  struct MonoBasicBlock * outb;
  struct MonoInst * inst;
  struct MonoInst * * locals;
  gboolean found;

  bb = cfg->cbb;
  if (count == 0) goto <D.45959>; else goto <D.45960>;
  <D.45959>:
  return;
  <D.45960>:
  D.45961 = cfg->verbose_level;
  if (D.45961 > 3) goto <D.45962>; else goto <D.45963>;
  <D.45962>:
  D.45964 = bb->block_num;
  printf ("%d item(s) on exit from B%d\n", count, D.45964);
  <D.45963>:
  D.45965 = bb->out_scount;
  if (D.45965 == 0) goto <D.45966>; else goto <D.45967>;
  <D.45966>:
  D.45968 = (short unsigned int) count;
  bb->out_scount = D.45968;
  found = 0;
  i = 0;
  goto <D.25377>;
  <D.25376>:
  D.45969 = bb->out_bb;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.45972 = D.45969 + D.45971;
  outb = *D.45972;
  D.45973 = outb->flags;
  D.45974 = D.45973 & 16;
  if (D.45974 != 0) goto <D.45975>; else goto <D.45976>;
  <D.45975>:
  // predicted unlikely by continue predictor.
  goto <D.25374>;
  <D.45976>:
  D.45977 = outb->in_stack;
  if (D.45977 != 0B) goto <D.45978>; else goto <D.45979>;
  <D.45978>:
  found = 1;
  D.45977 = outb->in_stack;
  bb->out_stack = D.45977;
  goto <D.25375>;
  <D.45979>:
  <D.25374>:
  i = i + 1;
  <D.25377>:
  D.45980 = bb->out_count;
  D.45981 = (int) D.45980;
  if (D.45981 > i) goto <D.25376>; else goto <D.25375>;
  <D.25375>:
  if (found == 0) goto <D.45982>; else goto <D.45983>;
  <D.45982>:
  D.45984 = cfg->mempool;
  D.45985 = (long unsigned int) count;
  D.45986 = (unsigned int) D.45985;
  D.45987 = D.45986 * 8;
  D.45988 = mono_mempool_alloc (D.45984, D.45987);
  bb->out_stack = D.45988;
  i = 0;
  goto <D.25379>;
  <D.25378>:
  D.45989 = cfg->inlined_method;
  if (D.45989 != 0B) goto <D.45990>; else goto <D.45991>;
  <D.45990>:
  D.45992 = bb->out_stack;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.45993 = D.45992 + D.45971;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.45994 = sp + D.45971;
  D.45995 = *D.45994;
  D.45996 = type_from_stack_type (D.45995);
  D.45997 = mono_compile_create_var (cfg, D.45996, 329);
  *D.45993 = D.45997;
  goto <D.45998>;
  <D.45991>:
  D.45992 = bb->out_stack;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.45993 = D.45992 + D.45971;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.45994 = sp + D.45971;
  D.45995 = *D.45994;
  D.45999 = mono_compile_get_interface_var (cfg, i, D.45995);
  *D.45993 = D.45999;
  <D.45998>:
  i = i + 1;
  <D.25379>:
  if (i < count) goto <D.25378>; else goto <D.25380>;
  <D.25380>:
  <D.45983>:
  <D.45967>:
  i = 0;
  goto <D.25383>;
  <D.25382>:
  D.45969 = bb->out_bb;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.45972 = D.45969 + D.45971;
  outb = *D.45972;
  D.45973 = outb->flags;
  D.45974 = D.45973 & 16;
  if (D.45974 != 0) goto <D.46000>; else goto <D.46001>;
  <D.46000>:
  // predicted unlikely by continue predictor.
  goto <D.25381>;
  <D.46001>:
  D.46002 = outb->in_scount;
  if (D.46002 != 0) goto <D.46003>; else goto <D.46004>;
  <D.46003>:
  D.46002 = outb->in_scount;
  D.45965 = bb->out_scount;
  if (D.46002 != D.45965) goto <D.46005>; else goto <D.46006>;
  <D.46005>:
  cfg->unverifiable = 1;
  return;
  <D.46006>:
  // predicted unlikely by continue predictor.
  goto <D.25381>;
  <D.46004>:
  D.45968 = (short unsigned int) count;
  outb->in_scount = D.45968;
  D.45992 = bb->out_stack;
  outb->in_stack = D.45992;
  <D.25381>:
  i = i + 1;
  <D.25383>:
  D.45980 = bb->out_count;
  D.45981 = (int) D.45980;
  if (D.45981 > i) goto <D.25382>; else goto <D.25384>;
  <D.25384>:
  locals = bb->out_stack;
  cfg->cbb = bb;
  i = 0;
  goto <D.25386>;
  <D.25385>:
  D.45984 = cfg->mempool;
  inst = mono_mempool_alloc (D.45984, 80);
  inst->data.op[1].const_val = 0;
  D.46007 = inst->data.op[1].const_val;
  inst->data.op[0].const_val = D.46007;
  inst->prev = 0B;
  D.46008 = inst->prev;
  inst->next = D.46008;
  inst->opcode = 424;
  inst->flags = 0;
  inst->type = 0;
  inst->dreg = -1;
  inst->sreg3 = -1;
  D.46009 = inst->sreg3;
  inst->sreg2 = D.46009;
  D.46010 = inst->sreg2;
  inst->sreg1 = D.46010;
  D.46011 = cfg->ip;
  inst->cil_code = D.46011;
  D.46012 = cfg->varinfo;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.46013 = locals + D.45971;
  D.46014 = *D.46013;
  D.46015 = D.46014->data.op[0].const_val;
  D.46016 = (long unsigned int) D.46015;
  D.46017 = D.46016 * 8;
  D.46018 = D.46012 + D.46017;
  D.46019 = *D.46018;
  D.46020 = D.46019->data.op[1].vtype;
  D.46021 = mono_type_to_regmove (cfg, D.46020);
  D.46022 = (short unsigned int) D.46021;
  inst->opcode = D.46022;
  D.46012 = cfg->varinfo;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.46013 = locals + D.45971;
  D.46014 = *D.46013;
  D.46015 = D.46014->data.op[0].const_val;
  D.46016 = (long unsigned int) D.46015;
  D.46017 = D.46016 * 8;
  D.46018 = D.46012 + D.46017;
  D.46019 = *D.46018;
  D.46023 = D.46019->klass;
  inst->klass = D.46023;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.45994 = sp + D.45971;
  D.45995 = *D.45994;
  D.46024 = D.45995->dreg;
  inst->sreg1 = D.46024;
  D.46012 = cfg->varinfo;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.46013 = locals + D.45971;
  D.46014 = *D.46013;
  D.46015 = D.46014->data.op[0].const_val;
  D.46016 = (long unsigned int) D.46015;
  D.46017 = D.46016 * 8;
  D.46018 = D.46012 + D.46017;
  D.46019 = *D.46018;
  D.46025 = D.46019->dreg;
  inst->dreg = D.46025;
  D.46026 = inst->opcode;
  if (D.46026 == 427) goto <D.46027>; else goto <D.46028>;
  <D.46027>:
  D.46012 = cfg->varinfo;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.46013 = locals + D.45971;
  D.46014 = *D.46013;
  D.46015 = D.46014->data.op[0].const_val;
  D.46016 = (long unsigned int) D.46015;
  D.46017 = D.46016 * 8;
  D.46018 = D.46012 + D.46017;
  D.46019 = *D.46018;
  D.46020 = D.46019->data.op[1].vtype;
  D.46029 = mono_class_from_mono_type (D.46020);
  inst->klass = D.46029;
  <D.46028>:
  D.46030 = cfg->cbb;
  D.46031 = D.46030->last_ins;
  if (D.46031 != 0B) goto <D.46032>; else goto <D.46033>;
  <D.46032>:
  D.46030 = cfg->cbb;
  D.46031 = D.46030->last_ins;
  D.46031->next = inst;
  D.46030 = cfg->cbb;
  D.46031 = D.46030->last_ins;
  inst->prev = D.46031;
  D.46030 = cfg->cbb;
  D.46030->last_ins = inst;
  goto <D.46034>;
  <D.46033>:
  D.46030 = cfg->cbb;
  D.46030 = cfg->cbb;
  D.46030->last_ins = inst;
  D.46031 = D.46030->last_ins;
  D.46030->code = D.46031;
  <D.46034>:
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.45994 = sp + D.45971;
  D.45995 = *D.45994;
  D.46035 = D.45995->cil_code;
  inst->cil_code = D.46035;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.45994 = sp + D.45971;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.46013 = locals + D.45971;
  D.46014 = *D.46013;
  *D.45994 = D.46014;
  D.45961 = cfg->verbose_level;
  if (D.45961 > 3) goto <D.46036>; else goto <D.46037>;
  <D.46036>:
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.46013 = locals + D.45971;
  D.46014 = *D.46013;
  D.46015 = D.46014->data.op[0].const_val;
  D.46038 = (int) D.46015;
  printf ("storing %d to temp %d\n", i, D.46038);
  <D.46037>:
  i = i + 1;
  <D.25386>:
  if (i < count) goto <D.25385>; else goto <D.25387>;
  <D.25387>:
  found = 1;
  bindex = 0;
  goto <D.25395>;
  <D.25394>:
  found = 0;
  goto <D.25388>;
  <D.25393>:
  D.45969 = bb->out_bb;
  D.46039 = (long unsigned int) bindex;
  D.46040 = D.46039 * 8;
  D.46041 = D.45969 + D.46040;
  outb = *D.46041;
  D.45973 = outb->flags;
  D.45974 = D.45973 & 16;
  if (D.45974 != 0) goto <D.46042>; else goto <D.46043>;
  <D.46042>:
  bindex = bindex + 1;
  // predicted unlikely by continue predictor.
  goto <D.25388>;
  <D.46043>:
  D.45977 = outb->in_stack;
  if (D.45977 != locals) goto <D.46044>; else goto <D.46045>;
  <D.46044>:
  i = 0;
  goto <D.25390>;
  <D.25389>:
  D.45984 = cfg->mempool;
  inst = mono_mempool_alloc (D.45984, 80);
  inst->data.op[1].const_val = 0;
  D.46007 = inst->data.op[1].const_val;
  inst->data.op[0].const_val = D.46007;
  inst->prev = 0B;
  D.46008 = inst->prev;
  inst->next = D.46008;
  inst->opcode = 424;
  inst->flags = 0;
  inst->type = 0;
  inst->dreg = -1;
  inst->sreg3 = -1;
  D.46009 = inst->sreg3;
  inst->sreg2 = D.46009;
  D.46010 = inst->sreg2;
  inst->sreg1 = D.46010;
  D.46011 = cfg->ip;
  inst->cil_code = D.46011;
  D.46012 = cfg->varinfo;
  D.45977 = outb->in_stack;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.46046 = D.45977 + D.45971;
  D.46047 = *D.46046;
  D.46048 = D.46047->data.op[0].const_val;
  D.46049 = (long unsigned int) D.46048;
  D.46050 = D.46049 * 8;
  D.46051 = D.46012 + D.46050;
  D.46052 = *D.46051;
  D.46053 = D.46052->data.op[1].vtype;
  D.46054 = mono_type_to_regmove (cfg, D.46053);
  D.46055 = (short unsigned int) D.46054;
  inst->opcode = D.46055;
  D.46012 = cfg->varinfo;
  D.45977 = outb->in_stack;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.46046 = D.45977 + D.45971;
  D.46047 = *D.46046;
  D.46048 = D.46047->data.op[0].const_val;
  D.46049 = (long unsigned int) D.46048;
  D.46050 = D.46049 * 8;
  D.46051 = D.46012 + D.46050;
  D.46052 = *D.46051;
  D.46056 = D.46052->klass;
  inst->klass = D.46056;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.45994 = sp + D.45971;
  D.45995 = *D.45994;
  D.46024 = D.45995->dreg;
  inst->sreg1 = D.46024;
  D.46012 = cfg->varinfo;
  D.45977 = outb->in_stack;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.46046 = D.45977 + D.45971;
  D.46047 = *D.46046;
  D.46048 = D.46047->data.op[0].const_val;
  D.46049 = (long unsigned int) D.46048;
  D.46050 = D.46049 * 8;
  D.46051 = D.46012 + D.46050;
  D.46052 = *D.46051;
  D.46057 = D.46052->dreg;
  inst->dreg = D.46057;
  D.46026 = inst->opcode;
  if (D.46026 == 427) goto <D.46058>; else goto <D.46059>;
  <D.46058>:
  D.46012 = cfg->varinfo;
  D.45977 = outb->in_stack;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.46046 = D.45977 + D.45971;
  D.46047 = *D.46046;
  D.46048 = D.46047->data.op[0].const_val;
  D.46049 = (long unsigned int) D.46048;
  D.46050 = D.46049 * 8;
  D.46051 = D.46012 + D.46050;
  D.46052 = *D.46051;
  D.46053 = D.46052->data.op[1].vtype;
  D.46060 = mono_class_from_mono_type (D.46053);
  inst->klass = D.46060;
  <D.46059>:
  D.46030 = cfg->cbb;
  D.46031 = D.46030->last_ins;
  if (D.46031 != 0B) goto <D.46061>; else goto <D.46062>;
  <D.46061>:
  D.46030 = cfg->cbb;
  D.46031 = D.46030->last_ins;
  D.46031->next = inst;
  D.46030 = cfg->cbb;
  D.46031 = D.46030->last_ins;
  inst->prev = D.46031;
  D.46030 = cfg->cbb;
  D.46030->last_ins = inst;
  goto <D.46063>;
  <D.46062>:
  D.46030 = cfg->cbb;
  D.46030 = cfg->cbb;
  D.46030->last_ins = inst;
  D.46031 = D.46030->last_ins;
  D.46030->code = D.46031;
  <D.46063>:
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.45994 = sp + D.45971;
  D.45995 = *D.45994;
  D.46035 = D.45995->cil_code;
  inst->cil_code = D.46035;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.45994 = sp + D.45971;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.46013 = locals + D.45971;
  D.46014 = *D.46013;
  *D.45994 = D.46014;
  D.45961 = cfg->verbose_level;
  if (D.45961 > 3) goto <D.46064>; else goto <D.46065>;
  <D.46064>:
  D.45977 = outb->in_stack;
  D.45970 = (long unsigned int) i;
  D.45971 = D.45970 * 8;
  D.46046 = D.45977 + D.45971;
  D.46047 = *D.46046;
  D.46048 = D.46047->data.op[0].const_val;
  D.46066 = (int) D.46048;
  printf ("storing %d to temp %d\n", i, D.46066);
  <D.46065>:
  i = i + 1;
  <D.25390>:
  if (i < count) goto <D.25389>; else goto <D.25391>;
  <D.25391>:
  locals = outb->in_stack;
  found = 1;
  goto <D.25392>;
  <D.46045>:
  bindex = bindex + 1;
  <D.25388>:
  D.45980 = bb->out_count;
  D.45981 = (int) D.45980;
  if (D.45981 > bindex) goto <D.25393>; else goto <D.25392>;
  <D.25392>:
  <D.25395>:
  if (found != 0) goto <D.25394>; else goto <D.25396>;
  <D.25396>:
}


mono_compile_get_interface_var (struct MonoCompile * cfg, int slot, struct MonoInst * ins)
{
  struct MonoMethodHeader * D.46068;
  <unnamed-unsigned:15> D.46069;
  int D.46070;
  struct MonoInst * D.46073;
  struct MonoType * D.46074;
  unsigned char D.46075;
  int D.46076;
  int D.46077;
  int D.46078;
  guint16 * D.46079;
  long unsigned int D.46080;
  long unsigned int D.46081;
  guint16 * D.46082;
  short unsigned int D.46083;
  struct MonoInst * * D.46086;
  long unsigned int D.46087;
  long unsigned int D.46088;
  struct MonoInst * * D.46089;
  struct MonoType * D.46090;
  long int D.46091;
  short unsigned int D.46092;
  struct MonoType * D.46093;
  struct MonoInst * res;
  int pos;
  int vnum;

  D.46068 = cfg->header;
  D.46069 = D.46068->max_stack;
  D.46070 = (int) D.46069;
  if (D.46070 <= slot) goto <D.46071>; else goto <D.46072>;
  <D.46071>:
  D.46074 = type_from_stack_type (ins);
  D.46073 = mono_compile_create_var (cfg, D.46074, 329);
  return D.46073;
  <D.46072>:
  D.46075 = ins->type;
  D.46076 = (int) D.46075;
  D.46077 = D.46076 + -1;
  D.46078 = slot * 8;
  pos = D.46077 + D.46078;
  D.46075 = ins->type;
  D.46076 = (int) D.46075;
  switch (D.46076) <default: <D.25354>, case 1: <D.25347>, case 2: <D.25348>, case 3: <D.25350>, case 4: <D.25349>, case 5: <D.25351>, case 6: <D.25352>>
  <D.25347>:
  <D.25348>:
  <D.25349>:
  <D.25350>:
  <D.25351>:
  <D.25352>:
  D.46079 = cfg->intvars;
  D.46080 = (long unsigned int) pos;
  D.46081 = D.46080 * 2;
  D.46082 = D.46079 + D.46081;
  D.46083 = *D.46082;
  vnum = (int) D.46083;
  if (vnum != 0) goto <D.46084>; else goto <D.46085>;
  <D.46084>:
  D.46086 = cfg->varinfo;
  D.46087 = (long unsigned int) vnum;
  D.46088 = D.46087 * 8;
  D.46089 = D.46086 + D.46088;
  D.46073 = *D.46089;
  return D.46073;
  <D.46085>:
  D.46090 = type_from_stack_type (ins);
  res = mono_compile_create_var (cfg, D.46090, 329);
  D.46079 = cfg->intvars;
  D.46080 = (long unsigned int) pos;
  D.46081 = D.46080 * 2;
  D.46082 = D.46079 + D.46081;
  D.46091 = res->data.op[0].const_val;
  D.46092 = (short unsigned int) D.46091;
  *D.46082 = D.46092;
  goto <D.25353>;
  <D.25354>:
  D.46093 = type_from_stack_type (ins);
  res = mono_compile_create_var (cfg, D.46093, 329);
  <D.25353>:
  D.46073 = res;
  return D.46073;
}


handle_box (struct MonoCompile * cfg, struct MonoInst * val, struct MonoClass * klass, int context_used, struct MonoBasicBlock * * out_cbb)
{
  struct MonoBasicBlock * D.46095;
  int D.46096;
  struct MonoMethod * D.46101;
  struct MonoInst * D.46102;
  struct MonoMethodSignature * D.46103;
  int pass_mrgctx.393;
  _Bool D.46105;
  long int D.46106;
  long int D.46107;
  int pass_vtable.394;
  struct MonoDomain * D.46113;
  struct MonoClass * D.46114;
  _Bool D.46115;
  long int D.46116;
  long int D.46117;
  struct MonoMemPool * D.46120;
  long int D.46121;
  struct MonoInst * D.46122;
  guint16 iftmp.395;
  long unsigned int D.46124;
  long unsigned int D.46125;
  int D.46129;
  int D.46130;
  const unsigned char * D.46131;
  void * iftmp.396;
  unsigned int D.46136;
  int D.46137;
  struct MonoInst * D.46138;
  int D.46142;
  unsigned int D.46145;
  unsigned int D.46146;
  unsigned int D.46147;
  unsigned int D.46148;
  int D.46149;
  unsigned int D.46150;
  unsigned int D.46151;
  int D.46152;
  unsigned int D.46153;
  unsigned int D.46154;
  int D.46155;
  long int D.46156;
  struct MonoInst * D.46157;
  int D.46158;
  int D.46159;
  int D.46160;
  long int D.46164;
  struct MonoInst * D.46165;
  int D.46166;
  int D.46167;
  unsigned int D.46170;
  unsigned int D.46171;
  int D.46172;
  unsigned char * D.46176;
  struct MonoBasicBlock * * D.46179;
  long int D.46180;
  unsigned char * D.46181;
  long int D.46182;
  long int D.46183;
  long unsigned int D.46184;
  long unsigned int D.46185;
  struct MonoBasicBlock * * D.46186;
  unsigned int D.46187;
  short unsigned int D.46192;
  short unsigned int D.46193;
  short unsigned int D.46195;
  short unsigned int D.46197;
  struct MonoBasicBlock * * D.46198;
  struct MonoBasicBlock * * D.46199;
  struct MonoBasicBlock * D.46200;
  void * D.46210;
  struct MonoBasicBlock * * D.46211;
  struct MonoBasicBlock * * D.46212;
  long unsigned int D.46216;
  unsigned int D.46219;
  unsigned int D.46220;
  int D.46221;
  long int D.46239;
  struct MonoInst * D.46240;
  int D.46241;
  int D.46242;
  long int D.46246;
  struct MonoInst * D.46247;
  int D.46248;
  int D.46249;
  unsigned int D.46252;
  unsigned int D.46253;
  int D.46254;
  unsigned char * D.46258;
  long int D.46261;
  long int D.46262;
  long unsigned int D.46263;
  long unsigned int D.46264;
  struct MonoBasicBlock * * D.46265;
  void * D.46281;
  struct MonoBasicBlock * * D.46282;
  struct MonoBasicBlock * * D.46283;
  unsigned int D.46289;
  unsigned int D.46290;
  int D.46291;
  long int D.46311;
  struct MonoInst * D.46312;
  struct MonoType * D.46313;
  unsigned int D.46314;
  short unsigned int D.46315;
  int D.46316;
  int D.46317;
  struct MonoInst * val.397;
  int D.46319;
  int D.46320;
  struct MonoClass * D.46321;
  long int D.46325;
  struct MonoInst * D.46326;
  int D.46327;
  int D.46328;
  long int D.46332;
  struct MonoInst * D.46333;
  int D.46334;
  int D.46335;
  unsigned int D.46338;
  unsigned int D.46339;
  int D.46340;
  unsigned char * D.46344;
  long int D.46347;
  long int D.46348;
  long unsigned int D.46349;
  long unsigned int D.46350;
  struct MonoBasicBlock * * D.46351;
  void * D.46367;
  struct MonoBasicBlock * * D.46368;
  struct MonoBasicBlock * * D.46369;
  unsigned int D.46375;
  unsigned int D.46376;
  int D.46377;
  unsigned char * D.46395;
  long int D.46398;
  long int D.46399;
  long unsigned int D.46400;
  long unsigned int D.46401;
  struct MonoBasicBlock * * D.46402;
  unsigned int D.46417;
  struct MonoInst * iftmp.398;
  unsigned int D.46419;
  unsigned int D.46420;
  struct MonoInst * * D.46423;
  long unsigned int D.46424;
  long unsigned int D.46425;
  struct MonoInst * * D.46426;
  long int D.46430;
  struct MonoInst * D.46431;
  int D.46432;
  int D.46433;
  unsigned char D.46434;
  unsigned char D.46435;
  struct MonoClass * D.46436;
  unsigned int D.46437;
  int D.46438;
  int D.46439;
  _Bool D.46440;
  long int D.46441;
  long int D.46442;
  struct MonoType * D.46445;
  int D.46446;
  struct MonoInst * iftmp.399;
  int D.46452;
  int D.46453;
  unsigned int D.46454;
  sizetype D.46457;
  sizetype D.46458;
  sizetype D.46459;
  struct MonoInst * * D.46460;
  struct MonoInst * iftmp.400;
  int D.46463;
  unsigned int D.46464;
  sizetype D.46467;
  sizetype D.46468;
  struct MonoInst * * D.46469;
  _Bool D.46471;
  long int D.46472;
  long int D.46473;
  _Bool D.46476;
  long int D.46477;
  long int D.46478;
  unsigned char D.46481;
  unsigned char D.46482;
  unsigned char D.46483;
  unsigned char D.46484;
  long int D.46488;
  struct MonoInst * D.46489;
  int D.46490;
  int D.46491;
  int D.46492;
  long int D.46496;
  struct MonoInst * D.46497;
  int D.46498;
  int D.46499;
  unsigned int D.46502;
  unsigned int D.46503;
  int D.46504;
  unsigned char * D.46508;
  long int D.46511;
  long int D.46512;
  long unsigned int D.46513;
  long unsigned int D.46514;
  struct MonoBasicBlock * * D.46515;
  void * D.46531;
  struct MonoBasicBlock * * D.46532;
  struct MonoBasicBlock * * D.46533;
  unsigned int D.46539;
  unsigned int D.46540;
  int D.46541;
  unsigned char * D.46559;
  long int D.46562;
  long int D.46563;
  long unsigned int D.46564;
  long unsigned int D.46565;
  struct MonoBasicBlock * * D.46566;
  struct MonoClass * D.46581;
  struct MonoType * D.46582;
  int D.46583;
  long int D.46587;
  struct MonoInst * D.46588;
  int D.46589;
  int D.46590;
  unsigned int D.46593;
  unsigned int D.46594;
  int D.46595;
  unsigned char * D.46599;
  long int D.46602;
  long int D.46603;
  long unsigned int D.46604;
  long unsigned int D.46605;
  struct MonoBasicBlock * * D.46606;
  void * D.46622;
  struct MonoBasicBlock * * D.46623;
  struct MonoBasicBlock * * D.46624;
  unsigned int D.46630;
  unsigned int D.46631;
  int D.46632;
  unsigned char * D.46650;
  long int D.46653;
  long int D.46654;
  long unsigned int D.46655;
  long unsigned int D.46656;
  struct MonoBasicBlock * * D.46657;
  unsigned int D.46674;
  short unsigned int D.46675;
  struct MonoClass * D.46676;
  struct MonoInst * alloc;
  struct MonoInst * ins;

  D.46095 = cfg->cbb;
  *out_cbb = D.46095;
  D.46096 = mono_class_is_nullable (klass);
  if (D.46096 != 0) goto <D.46097>; else goto <D.46098>;
  <D.46097>:
  {
    struct MonoMethod * method;

    method = mono_class_get_method_from_name (klass, "Box", 1);
    if (context_used != 0) goto <D.46099>; else goto <D.46100>;
    <D.46099>:
    {
      struct MonoInst * addr;
      struct MonoInst * rgctx;

      addr = emit_get_rgctx_method (cfg, context_used, method, 6);
      D.46101 = cfg->current_method;
      rgctx = emit_get_rgctx (cfg, D.46101, context_used);
      D.46103 = mono_method_signature (method);
      D.46102 = mono_emit_calli (cfg, D.46103, &val, addr, 0B, rgctx);
      return D.46102;
    }
    <D.46100>:
    {
      gboolean pass_vtable;
      gboolean pass_mrgctx;
      struct MonoInst * rgctx_arg;

      try
        {
          rgctx_arg = 0B;
          check_method_sharing (cfg, method, &pass_vtable, &pass_mrgctx);
          pass_mrgctx.393 = pass_mrgctx;
          D.46105 = pass_mrgctx.393 != 0;
          D.46106 = (long int) D.46105;
          D.46107 = __builtin_expect (D.46106, 0);
          if (D.46107 != 0) goto <D.46108>; else goto <D.46109>;
          <D.46108>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3830, "!pass_mrgctx");
          <D.46109>:
          pass_vtable.394 = pass_vtable;
          if (pass_vtable.394 != 0) goto <D.46111>; else goto <D.46112>;
          <D.46111>:
          {
            struct MonoVTable * vtable;

            D.46113 = cfg->domain;
            D.46114 = method->klass;
            vtable = mono_class_vtable (D.46113, D.46114);
            D.46115 = vtable == 0B;
            D.46116 = (long int) D.46115;
            D.46117 = __builtin_expect (D.46116, 0);
            if (D.46117 != 0) goto <D.46118>; else goto <D.46119>;
            <D.46118>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3835, "vtable");
            <D.46119>:
            D.46120 = cfg->mempool;
            rgctx_arg = mono_mempool_alloc (D.46120, 80);
            rgctx_arg->data.op[1].const_val = 0;
            D.46121 = rgctx_arg->data.op[1].const_val;
            rgctx_arg->data.op[0].const_val = D.46121;
            rgctx_arg->prev = 0B;
            D.46122 = rgctx_arg->prev;
            rgctx_arg->next = D.46122;
            D.46124 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.46125 = D.46124 & 33554432;
            if (D.46125 != 0) goto <D.46126>; else goto <D.46127>;
            <D.46126>:
            iftmp.395 = 732;
            goto <D.46128>;
            <D.46127>:
            iftmp.395 = 363;
            <D.46128>:
            rgctx_arg->opcode = iftmp.395;
            rgctx_arg->flags = 0;
            rgctx_arg->type = 0;
            rgctx_arg->dreg = -1;
            rgctx_arg->sreg3 = -1;
            D.46129 = rgctx_arg->sreg3;
            rgctx_arg->sreg2 = D.46129;
            D.46130 = rgctx_arg->sreg2;
            rgctx_arg->sreg1 = D.46130;
            D.46131 = cfg->ip;
            rgctx_arg->cil_code = D.46131;
            D.46124 = BIT_FIELD_REF <*cfg, 64, 5568>;
            D.46125 = D.46124 & 33554432;
            if (D.46125 != 0) goto <D.46133>; else goto <D.46134>;
            <D.46133>:
            iftmp.396 = vtable->klass;
            goto <D.46135>;
            <D.46134>:
            iftmp.396 = vtable;
            <D.46135>:
            rgctx_arg->data.op[0].p = iftmp.396;
            rgctx_arg->data.op[1].src = 14B;
            rgctx_arg->type = 3;
            D.46136 = alloc_dreg (cfg, 3);
            D.46137 = (int) D.46136;
            rgctx_arg->dreg = D.46137;
            D.46095 = cfg->cbb;
            D.46138 = D.46095->last_ins;
            if (D.46138 != 0B) goto <D.46139>; else goto <D.46140>;
            <D.46139>:
            D.46095 = cfg->cbb;
            D.46138 = D.46095->last_ins;
            D.46138->next = rgctx_arg;
            D.46095 = cfg->cbb;
            D.46138 = D.46095->last_ins;
            rgctx_arg->prev = D.46138;
            D.46095 = cfg->cbb;
            D.46095->last_ins = rgctx_arg;
            goto <D.46141>;
            <D.46140>:
            D.46095 = cfg->cbb;
            D.46095 = cfg->cbb;
            D.46095->last_ins = rgctx_arg;
            D.46138 = D.46095->last_ins;
            D.46095->code = D.46138;
            <D.46141>:
          }
          <D.46112>:
          D.46102 = mono_emit_method_call_full (cfg, method, 0B, 0, &val, 0B, 0B, rgctx_arg);
          return D.46102;
        }
      finally
        {
          pass_vtable = {CLOBBER};
          pass_mrgctx = {CLOBBER};
        }
    }
  }
  <D.46098>:
  D.46142 = mini_is_gsharedvt_klass (cfg, klass);
  if (D.46142 != 0) goto <D.46143>; else goto <D.46144>;
  <D.46143>:
  {
    struct MonoBasicBlock * is_ref_bb;
    struct MonoBasicBlock * is_nullable_bb;
    struct MonoBasicBlock * end_bb;
    struct MonoInst * res;
    struct MonoInst * is_ref;
    struct MonoInst * src_var;
    struct MonoInst * addr;
    int addr_reg;
    int dreg;

    D.46145 = alloc_ireg (cfg);
    dreg = (int) D.46145;
    D.46120 = cfg->mempool;
    is_ref_bb = mono_mempool_alloc0 (D.46120, 296);
    D.46146 = cfg->num_bblocks;
    D.46147 = D.46146;
    D.46148 = D.46147 + 1;
    cfg->num_bblocks = D.46148;
    D.46149 = (int) D.46147;
    is_ref_bb->block_num = D.46149;
    D.46120 = cfg->mempool;
    is_nullable_bb = mono_mempool_alloc0 (D.46120, 296);
    D.46146 = cfg->num_bblocks;
    D.46150 = D.46146;
    D.46151 = D.46150 + 1;
    cfg->num_bblocks = D.46151;
    D.46152 = (int) D.46150;
    is_nullable_bb->block_num = D.46152;
    D.46120 = cfg->mempool;
    end_bb = mono_mempool_alloc0 (D.46120, 296);
    D.46146 = cfg->num_bblocks;
    D.46153 = D.46146;
    D.46154 = D.46153 + 1;
    cfg->num_bblocks = D.46154;
    D.46155 = (int) D.46153;
    end_bb->block_num = D.46155;
    is_ref = emit_get_gsharedvt_info_klass (cfg, klass, 19);
    {
      struct MonoInst * inst;

      D.46120 = cfg->mempool;
      inst = mono_mempool_alloc (D.46120, 80);
      inst->data.op[1].const_val = 0;
      D.46156 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.46156;
      inst->prev = 0B;
      D.46157 = inst->prev;
      inst->next = D.46157;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.46158 = inst->sreg3;
      inst->sreg2 = D.46158;
      D.46159 = inst->sreg2;
      inst->sreg1 = D.46159;
      D.46131 = cfg->ip;
      inst->cil_code = D.46131;
      inst->dreg = -1;
      D.46160 = is_ref->dreg;
      inst->sreg1 = D.46160;
      inst->data.op[1].const_val = 1;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46161>; else goto <D.46162>;
      <D.46161>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46138->next = inst;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      inst->prev = D.46138;
      D.46095 = cfg->cbb;
      D.46095->last_ins = inst;
      goto <D.46163>;
      <D.46162>:
      D.46095 = cfg->cbb;
      D.46095 = cfg->cbb;
      D.46095->last_ins = inst;
      D.46138 = D.46095->last_ins;
      D.46095->code = D.46138;
      <D.46163>:
    }
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.46120 = cfg->mempool;
      ins = mono_mempool_alloc (D.46120, 80);
      ins->data.op[1].const_val = 0;
      D.46164 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.46164;
      ins->prev = 0B;
      D.46165 = ins->prev;
      ins->next = D.46165;
      ins->opcode = 648;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.46166 = ins->sreg3;
      ins->sreg2 = D.46166;
      D.46167 = ins->sreg2;
      ins->sreg1 = D.46167;
      D.46131 = cfg->ip;
      ins->cil_code = D.46131;
      if (0 != 0) goto <D.46168>; else goto <D.46169>;
      <D.46168>:
      D.46120 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.46120, 296);
      D.46146 = cfg->num_bblocks;
      D.46170 = D.46146;
      D.46171 = D.46170 + 1;
      cfg->num_bblocks = D.46171;
      D.46172 = (int) D.46170;
      falsebb->block_num = D.46172;
      ins->data.op[0].target_block = is_ref_bb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, is_ref_bb);
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46173>; else goto <D.46174>;
      <D.46173>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46138->next = ins;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      ins->prev = D.46138;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      goto <D.46175>;
      <D.46174>:
      D.46095 = cfg->cbb;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      D.46138 = D.46095->last_ins;
      D.46095->code = D.46138;
      <D.46175>:
      D.46176 = falsebb->cil_code;
      if (D.46176 != 0B) goto <D.46177>; else goto <D.46178>;
      <D.46177>:
      D.46179 = cfg->cil_offset_to_bb;
      D.46176 = falsebb->cil_code;
      D.46180 = (long int) D.46176;
      D.46181 = cfg->cil_start;
      D.46182 = (long int) D.46181;
      D.46183 = D.46180 - D.46182;
      D.46184 = (long unsigned int) D.46183;
      D.46185 = D.46184 * 8;
      D.46186 = D.46179 + D.46185;
      *D.46186 = falsebb;
      <D.46178>:
      D.46187 = cfg->real_offset;
      falsebb->real_offset = D.46187;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46191>; else goto <D.46188>;
      <D.46191>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 <= 9) goto <D.46189>; else goto <D.46194>;
      <D.46194>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 <= 9) goto <D.46189>; else goto <D.46196>;
      <D.46196>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 <= 9) goto <D.46189>; else goto <D.46188>;
      <D.46189>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      D.46200 = *D.46199;
      if (D.46200 == 0B) goto <D.46201>; else goto <D.46188>;
      <D.46201>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      *D.46199 = falsebb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      goto <D.46190>;
      <D.46188>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 == 0B) goto <D.46202>; else goto <D.46204>;
      <D.46204>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 442) goto <D.46205>; else goto <D.46203>;
      <D.46205>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 759) goto <D.46206>; else goto <D.46203>;
      <D.46206>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 > 9) goto <D.46207>; else goto <D.46203>;
      <D.46207>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 > 9) goto <D.46208>; else goto <D.46203>;
      <D.46208>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 > 9) goto <D.46202>; else goto <D.46203>;
      <D.46202>:
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      <D.46203>:
      <D.46190>:
      D.46095 = cfg->cbb;
      D.46095->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.46209>;
      <D.46169>:
      D.46120 = cfg->mempool;
      D.46210 = mono_mempool_alloc (D.46120, 16);
      ins->data.op[1].many_blocks = D.46210;
      D.46211 = ins->data.op[1].many_blocks;
      *D.46211 = is_ref_bb;
      D.46211 = ins->data.op[1].many_blocks;
      D.46212 = D.46211 + 8;
      *D.46212 = 0B;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, is_ref_bb);
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46213>; else goto <D.46214>;
      <D.46213>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46138->next = ins;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      ins->prev = D.46138;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      goto <D.46215>;
      <D.46214>:
      D.46095 = cfg->cbb;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      D.46138 = D.46095->last_ins;
      D.46095->code = D.46138;
      <D.46215>:
      D.46124 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.46216 = D.46124 & 268435456;
      if (D.46216 == 0) goto <D.46217>; else goto <D.46218>;
      <D.46217>:
      D.46120 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.46120, 296);
      D.46146 = cfg->num_bblocks;
      D.46219 = D.46146;
      D.46220 = D.46219 + 1;
      cfg->num_bblocks = D.46220;
      D.46221 = (int) D.46219;
      falsebb->block_num = D.46221;
      D.46211 = ins->data.op[1].many_blocks;
      D.46212 = D.46211 + 8;
      *D.46212 = falsebb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      D.46176 = falsebb->cil_code;
      if (D.46176 != 0B) goto <D.46222>; else goto <D.46223>;
      <D.46222>:
      D.46179 = cfg->cil_offset_to_bb;
      D.46176 = falsebb->cil_code;
      D.46180 = (long int) D.46176;
      D.46181 = cfg->cil_start;
      D.46182 = (long int) D.46181;
      D.46183 = D.46180 - D.46182;
      D.46184 = (long unsigned int) D.46183;
      D.46185 = D.46184 * 8;
      D.46186 = D.46179 + D.46185;
      *D.46186 = falsebb;
      <D.46223>:
      D.46187 = cfg->real_offset;
      falsebb->real_offset = D.46187;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46227>; else goto <D.46224>;
      <D.46227>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 <= 9) goto <D.46225>; else goto <D.46228>;
      <D.46228>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 <= 9) goto <D.46225>; else goto <D.46229>;
      <D.46229>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 <= 9) goto <D.46225>; else goto <D.46224>;
      <D.46225>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      D.46200 = *D.46199;
      if (D.46200 == 0B) goto <D.46230>; else goto <D.46224>;
      <D.46230>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      *D.46199 = falsebb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      goto <D.46226>;
      <D.46224>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 == 0B) goto <D.46231>; else goto <D.46233>;
      <D.46233>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 442) goto <D.46234>; else goto <D.46232>;
      <D.46234>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 759) goto <D.46235>; else goto <D.46232>;
      <D.46235>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 > 9) goto <D.46236>; else goto <D.46232>;
      <D.46236>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 > 9) goto <D.46237>; else goto <D.46232>;
      <D.46237>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 > 9) goto <D.46231>; else goto <D.46232>;
      <D.46231>:
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      <D.46232>:
      <D.46226>:
      D.46095 = cfg->cbb;
      D.46095->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.46238>;
      <D.46218>:
      D.46095 = cfg->cbb;
      D.46095->extended = 1;
      <D.46238>:
      <D.46209>:
    }
    {
      struct MonoInst * inst;

      D.46120 = cfg->mempool;
      inst = mono_mempool_alloc (D.46120, 80);
      inst->data.op[1].const_val = 0;
      D.46239 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.46239;
      inst->prev = 0B;
      D.46240 = inst->prev;
      inst->next = D.46240;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.46241 = inst->sreg3;
      inst->sreg2 = D.46241;
      D.46242 = inst->sreg2;
      inst->sreg1 = D.46242;
      D.46131 = cfg->ip;
      inst->cil_code = D.46131;
      inst->dreg = -1;
      D.46160 = is_ref->dreg;
      inst->sreg1 = D.46160;
      inst->data.op[1].const_val = 2;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46243>; else goto <D.46244>;
      <D.46243>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46138->next = inst;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      inst->prev = D.46138;
      D.46095 = cfg->cbb;
      D.46095->last_ins = inst;
      goto <D.46245>;
      <D.46244>:
      D.46095 = cfg->cbb;
      D.46095 = cfg->cbb;
      D.46095->last_ins = inst;
      D.46138 = D.46095->last_ins;
      D.46095->code = D.46138;
      <D.46245>:
    }
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.46120 = cfg->mempool;
      ins = mono_mempool_alloc (D.46120, 80);
      ins->data.op[1].const_val = 0;
      D.46246 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.46246;
      ins->prev = 0B;
      D.46247 = ins->prev;
      ins->next = D.46247;
      ins->opcode = 648;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.46248 = ins->sreg3;
      ins->sreg2 = D.46248;
      D.46249 = ins->sreg2;
      ins->sreg1 = D.46249;
      D.46131 = cfg->ip;
      ins->cil_code = D.46131;
      if (0 != 0) goto <D.46250>; else goto <D.46251>;
      <D.46250>:
      D.46120 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.46120, 296);
      D.46146 = cfg->num_bblocks;
      D.46252 = D.46146;
      D.46253 = D.46252 + 1;
      cfg->num_bblocks = D.46253;
      D.46254 = (int) D.46252;
      falsebb->block_num = D.46254;
      ins->data.op[0].target_block = is_nullable_bb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, is_nullable_bb);
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46255>; else goto <D.46256>;
      <D.46255>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46138->next = ins;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      ins->prev = D.46138;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      goto <D.46257>;
      <D.46256>:
      D.46095 = cfg->cbb;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      D.46138 = D.46095->last_ins;
      D.46095->code = D.46138;
      <D.46257>:
      D.46258 = falsebb->cil_code;
      if (D.46258 != 0B) goto <D.46259>; else goto <D.46260>;
      <D.46259>:
      D.46179 = cfg->cil_offset_to_bb;
      D.46258 = falsebb->cil_code;
      D.46261 = (long int) D.46258;
      D.46181 = cfg->cil_start;
      D.46182 = (long int) D.46181;
      D.46262 = D.46261 - D.46182;
      D.46263 = (long unsigned int) D.46262;
      D.46264 = D.46263 * 8;
      D.46265 = D.46179 + D.46264;
      *D.46265 = falsebb;
      <D.46260>:
      D.46187 = cfg->real_offset;
      falsebb->real_offset = D.46187;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46269>; else goto <D.46266>;
      <D.46269>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 <= 9) goto <D.46267>; else goto <D.46270>;
      <D.46270>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 <= 9) goto <D.46267>; else goto <D.46271>;
      <D.46271>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 <= 9) goto <D.46267>; else goto <D.46266>;
      <D.46267>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      D.46200 = *D.46199;
      if (D.46200 == 0B) goto <D.46272>; else goto <D.46266>;
      <D.46272>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      *D.46199 = falsebb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      goto <D.46268>;
      <D.46266>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 == 0B) goto <D.46273>; else goto <D.46275>;
      <D.46275>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 442) goto <D.46276>; else goto <D.46274>;
      <D.46276>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 759) goto <D.46277>; else goto <D.46274>;
      <D.46277>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 > 9) goto <D.46278>; else goto <D.46274>;
      <D.46278>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 > 9) goto <D.46279>; else goto <D.46274>;
      <D.46279>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 > 9) goto <D.46273>; else goto <D.46274>;
      <D.46273>:
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      <D.46274>:
      <D.46268>:
      D.46095 = cfg->cbb;
      D.46095->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.46280>;
      <D.46251>:
      D.46120 = cfg->mempool;
      D.46281 = mono_mempool_alloc (D.46120, 16);
      ins->data.op[1].many_blocks = D.46281;
      D.46282 = ins->data.op[1].many_blocks;
      *D.46282 = is_nullable_bb;
      D.46282 = ins->data.op[1].many_blocks;
      D.46283 = D.46282 + 8;
      *D.46283 = 0B;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, is_nullable_bb);
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46284>; else goto <D.46285>;
      <D.46284>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46138->next = ins;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      ins->prev = D.46138;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      goto <D.46286>;
      <D.46285>:
      D.46095 = cfg->cbb;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      D.46138 = D.46095->last_ins;
      D.46095->code = D.46138;
      <D.46286>:
      D.46124 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.46216 = D.46124 & 268435456;
      if (D.46216 == 0) goto <D.46287>; else goto <D.46288>;
      <D.46287>:
      D.46120 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.46120, 296);
      D.46146 = cfg->num_bblocks;
      D.46289 = D.46146;
      D.46290 = D.46289 + 1;
      cfg->num_bblocks = D.46290;
      D.46291 = (int) D.46289;
      falsebb->block_num = D.46291;
      D.46282 = ins->data.op[1].many_blocks;
      D.46283 = D.46282 + 8;
      *D.46283 = falsebb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      D.46258 = falsebb->cil_code;
      if (D.46258 != 0B) goto <D.46292>; else goto <D.46293>;
      <D.46292>:
      D.46179 = cfg->cil_offset_to_bb;
      D.46258 = falsebb->cil_code;
      D.46261 = (long int) D.46258;
      D.46181 = cfg->cil_start;
      D.46182 = (long int) D.46181;
      D.46262 = D.46261 - D.46182;
      D.46263 = (long unsigned int) D.46262;
      D.46264 = D.46263 * 8;
      D.46265 = D.46179 + D.46264;
      *D.46265 = falsebb;
      <D.46293>:
      D.46187 = cfg->real_offset;
      falsebb->real_offset = D.46187;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46297>; else goto <D.46294>;
      <D.46297>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 <= 9) goto <D.46295>; else goto <D.46298>;
      <D.46298>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 <= 9) goto <D.46295>; else goto <D.46299>;
      <D.46299>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 <= 9) goto <D.46295>; else goto <D.46294>;
      <D.46295>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      D.46200 = *D.46199;
      if (D.46200 == 0B) goto <D.46300>; else goto <D.46294>;
      <D.46300>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      *D.46199 = falsebb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      goto <D.46296>;
      <D.46294>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 == 0B) goto <D.46301>; else goto <D.46303>;
      <D.46303>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 442) goto <D.46304>; else goto <D.46302>;
      <D.46304>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 759) goto <D.46305>; else goto <D.46302>;
      <D.46305>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 > 9) goto <D.46306>; else goto <D.46302>;
      <D.46306>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 > 9) goto <D.46307>; else goto <D.46302>;
      <D.46307>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 > 9) goto <D.46301>; else goto <D.46302>;
      <D.46301>:
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      <D.46302>:
      <D.46296>:
      D.46095 = cfg->cbb;
      D.46095->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.46308>;
      <D.46288>:
      D.46095 = cfg->cbb;
      D.46095->extended = 1;
      <D.46308>:
      <D.46280>:
    }
    alloc = handle_alloc (cfg, klass, 1, context_used);
    if (alloc == 0B) goto <D.46309>; else goto <D.46310>;
    <D.46309>:
    D.46102 = 0B;
    return D.46102;
    <D.46310>:
    D.46120 = cfg->mempool;
    ins = mono_mempool_alloc (D.46120, 80);
    ins->data.op[1].const_val = 0;
    D.46311 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.46311;
    ins->prev = 0B;
    D.46312 = ins->prev;
    ins->next = D.46312;
    D.46313 = &klass->byval_arg;
    D.46314 = mono_type_to_store_membase (cfg, D.46313);
    D.46315 = (short unsigned int) D.46314;
    ins->opcode = D.46315;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.46316 = ins->sreg3;
    ins->sreg2 = D.46316;
    D.46317 = ins->sreg2;
    ins->sreg1 = D.46317;
    D.46131 = cfg->ip;
    ins->cil_code = D.46131;
    val.397 = val;
    D.46319 = val.397->dreg;
    ins->sreg1 = D.46319;
    D.46320 = alloc->dreg;
    ins->dreg = D.46320;
    ins->data.op[0].const_val = 16;
    D.46313 = &klass->byval_arg;
    type_to_eval_stack_type (cfg, D.46313, ins);
    D.46313 = &klass->byval_arg;
    D.46321 = mono_class_from_mono_type (D.46313);
    ins->klass = D.46321;
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    if (D.46138 != 0B) goto <D.46322>; else goto <D.46323>;
    <D.46322>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46138->next = ins;
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    ins->prev = D.46138;
    D.46095 = cfg->cbb;
    D.46095->last_ins = ins;
    goto <D.46324>;
    <D.46323>:
    D.46095 = cfg->cbb;
    D.46095 = cfg->cbb;
    D.46095->last_ins = ins;
    D.46138 = D.46095->last_ins;
    D.46095->code = D.46138;
    <D.46324>:
    ins->opcode = 387;
    D.46120 = cfg->mempool;
    res = mono_mempool_alloc (D.46120, 80);
    res->data.op[1].const_val = 0;
    D.46325 = res->data.op[1].const_val;
    res->data.op[0].const_val = D.46325;
    res->prev = 0B;
    D.46326 = res->prev;
    res->next = D.46326;
    res->opcode = 424;
    res->flags = 0;
    res->type = 0;
    res->dreg = -1;
    res->sreg3 = -1;
    D.46327 = res->sreg3;
    res->sreg2 = D.46327;
    D.46328 = res->sreg2;
    res->sreg1 = D.46328;
    D.46131 = cfg->ip;
    res->cil_code = D.46131;
    res->dreg = dreg;
    D.46320 = alloc->dreg;
    res->sreg1 = D.46320;
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    if (D.46138 != 0B) goto <D.46329>; else goto <D.46330>;
    <D.46329>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46138->next = res;
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    res->prev = D.46138;
    D.46095 = cfg->cbb;
    D.46095->last_ins = res;
    goto <D.46331>;
    <D.46330>:
    D.46095 = cfg->cbb;
    D.46095 = cfg->cbb;
    D.46095->last_ins = res;
    D.46138 = D.46095->last_ins;
    D.46095->code = D.46138;
    <D.46331>:
    res->type = 6;
    res->klass = klass;
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.46120 = cfg->mempool;
      ins = mono_mempool_alloc (D.46120, 80);
      ins->data.op[1].const_val = 0;
      D.46332 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.46332;
      ins->prev = 0B;
      D.46333 = ins->prev;
      ins->next = D.46333;
      ins->opcode = 442;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.46334 = ins->sreg3;
      ins->sreg2 = D.46334;
      D.46335 = ins->sreg2;
      ins->sreg1 = D.46335;
      D.46131 = cfg->ip;
      ins->cil_code = D.46131;
      if (1 != 0) goto <D.46336>; else goto <D.46337>;
      <D.46336>:
      D.46120 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.46120, 296);
      D.46146 = cfg->num_bblocks;
      D.46338 = D.46146;
      D.46339 = D.46338 + 1;
      cfg->num_bblocks = D.46339;
      D.46340 = (int) D.46338;
      falsebb->block_num = D.46340;
      ins->data.op[0].target_block = end_bb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, end_bb);
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46341>; else goto <D.46342>;
      <D.46341>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46138->next = ins;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      ins->prev = D.46138;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      goto <D.46343>;
      <D.46342>:
      D.46095 = cfg->cbb;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      D.46138 = D.46095->last_ins;
      D.46095->code = D.46138;
      <D.46343>:
      D.46344 = falsebb->cil_code;
      if (D.46344 != 0B) goto <D.46345>; else goto <D.46346>;
      <D.46345>:
      D.46179 = cfg->cil_offset_to_bb;
      D.46344 = falsebb->cil_code;
      D.46347 = (long int) D.46344;
      D.46181 = cfg->cil_start;
      D.46182 = (long int) D.46181;
      D.46348 = D.46347 - D.46182;
      D.46349 = (long unsigned int) D.46348;
      D.46350 = D.46349 * 8;
      D.46351 = D.46179 + D.46350;
      *D.46351 = falsebb;
      <D.46346>:
      D.46187 = cfg->real_offset;
      falsebb->real_offset = D.46187;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46355>; else goto <D.46352>;
      <D.46355>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 <= 9) goto <D.46353>; else goto <D.46356>;
      <D.46356>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 <= 9) goto <D.46353>; else goto <D.46357>;
      <D.46357>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 <= 9) goto <D.46353>; else goto <D.46352>;
      <D.46353>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      D.46200 = *D.46199;
      if (D.46200 == 0B) goto <D.46358>; else goto <D.46352>;
      <D.46358>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      *D.46199 = falsebb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      goto <D.46354>;
      <D.46352>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 == 0B) goto <D.46359>; else goto <D.46361>;
      <D.46361>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 442) goto <D.46362>; else goto <D.46360>;
      <D.46362>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 759) goto <D.46363>; else goto <D.46360>;
      <D.46363>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 > 9) goto <D.46364>; else goto <D.46360>;
      <D.46364>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 > 9) goto <D.46365>; else goto <D.46360>;
      <D.46365>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 > 9) goto <D.46359>; else goto <D.46360>;
      <D.46359>:
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      <D.46360>:
      <D.46354>:
      D.46095 = cfg->cbb;
      D.46095->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.46366>;
      <D.46337>:
      D.46120 = cfg->mempool;
      D.46367 = mono_mempool_alloc (D.46120, 16);
      ins->data.op[1].many_blocks = D.46367;
      D.46368 = ins->data.op[1].many_blocks;
      *D.46368 = end_bb;
      D.46368 = ins->data.op[1].many_blocks;
      D.46369 = D.46368 + 8;
      *D.46369 = 0B;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, end_bb);
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46370>; else goto <D.46371>;
      <D.46370>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46138->next = ins;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      ins->prev = D.46138;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      goto <D.46372>;
      <D.46371>:
      D.46095 = cfg->cbb;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      D.46138 = D.46095->last_ins;
      D.46095->code = D.46138;
      <D.46372>:
      D.46124 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.46216 = D.46124 & 268435456;
      if (D.46216 == 0) goto <D.46373>; else goto <D.46374>;
      <D.46373>:
      D.46120 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.46120, 296);
      D.46146 = cfg->num_bblocks;
      D.46375 = D.46146;
      D.46376 = D.46375 + 1;
      cfg->num_bblocks = D.46376;
      D.46377 = (int) D.46375;
      falsebb->block_num = D.46377;
      D.46368 = ins->data.op[1].many_blocks;
      D.46369 = D.46368 + 8;
      *D.46369 = falsebb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      D.46344 = falsebb->cil_code;
      if (D.46344 != 0B) goto <D.46378>; else goto <D.46379>;
      <D.46378>:
      D.46179 = cfg->cil_offset_to_bb;
      D.46344 = falsebb->cil_code;
      D.46347 = (long int) D.46344;
      D.46181 = cfg->cil_start;
      D.46182 = (long int) D.46181;
      D.46348 = D.46347 - D.46182;
      D.46349 = (long unsigned int) D.46348;
      D.46350 = D.46349 * 8;
      D.46351 = D.46179 + D.46350;
      *D.46351 = falsebb;
      <D.46379>:
      D.46187 = cfg->real_offset;
      falsebb->real_offset = D.46187;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46383>; else goto <D.46380>;
      <D.46383>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 <= 9) goto <D.46381>; else goto <D.46384>;
      <D.46384>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 <= 9) goto <D.46381>; else goto <D.46385>;
      <D.46385>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 <= 9) goto <D.46381>; else goto <D.46380>;
      <D.46381>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      D.46200 = *D.46199;
      if (D.46200 == 0B) goto <D.46386>; else goto <D.46380>;
      <D.46386>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      *D.46199 = falsebb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      goto <D.46382>;
      <D.46380>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 == 0B) goto <D.46387>; else goto <D.46389>;
      <D.46389>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 442) goto <D.46390>; else goto <D.46388>;
      <D.46390>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 759) goto <D.46391>; else goto <D.46388>;
      <D.46391>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 > 9) goto <D.46392>; else goto <D.46388>;
      <D.46392>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 > 9) goto <D.46393>; else goto <D.46388>;
      <D.46393>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 > 9) goto <D.46387>; else goto <D.46388>;
      <D.46387>:
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      <D.46388>:
      <D.46382>:
      D.46095 = cfg->cbb;
      D.46095->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.46394>;
      <D.46374>:
      D.46095 = cfg->cbb;
      D.46095->extended = 1;
      <D.46394>:
      <D.46366>:
    }
    D.46395 = is_ref_bb->cil_code;
    if (D.46395 != 0B) goto <D.46396>; else goto <D.46397>;
    <D.46396>:
    D.46179 = cfg->cil_offset_to_bb;
    D.46395 = is_ref_bb->cil_code;
    D.46398 = (long int) D.46395;
    D.46181 = cfg->cil_start;
    D.46182 = (long int) D.46181;
    D.46399 = D.46398 - D.46182;
    D.46400 = (long unsigned int) D.46399;
    D.46401 = D.46400 * 8;
    D.46402 = D.46179 + D.46401;
    *D.46402 = is_ref_bb;
    <D.46397>:
    D.46187 = cfg->real_offset;
    is_ref_bb->real_offset = D.46187;
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    if (D.46138 != 0B) goto <D.46406>; else goto <D.46403>;
    <D.46406>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    D.46193 = D.46192 + 64985;
    if (D.46193 <= 9) goto <D.46404>; else goto <D.46407>;
    <D.46407>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    D.46195 = D.46192 + 64878;
    if (D.46195 <= 9) goto <D.46404>; else goto <D.46408>;
    <D.46408>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    D.46197 = D.46192 + 64888;
    if (D.46197 <= 9) goto <D.46404>; else goto <D.46403>;
    <D.46404>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46198 = D.46138->data.op[1].many_blocks;
    D.46199 = D.46198 + 8;
    D.46200 = *D.46199;
    if (D.46200 == 0B) goto <D.46409>; else goto <D.46403>;
    <D.46409>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46198 = D.46138->data.op[1].many_blocks;
    D.46199 = D.46198 + 8;
    *D.46199 = is_ref_bb;
    D.46095 = cfg->cbb;
    mono_link_bblock (cfg, D.46095, is_ref_bb);
    goto <D.46405>;
    <D.46403>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    if (D.46138 == 0B) goto <D.46410>; else goto <D.46412>;
    <D.46412>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    if (D.46192 != 442) goto <D.46413>; else goto <D.46411>;
    <D.46413>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    if (D.46192 != 759) goto <D.46414>; else goto <D.46411>;
    <D.46414>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    D.46193 = D.46192 + 64985;
    if (D.46193 > 9) goto <D.46415>; else goto <D.46411>;
    <D.46415>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    D.46195 = D.46192 + 64878;
    if (D.46195 > 9) goto <D.46416>; else goto <D.46411>;
    <D.46416>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    D.46197 = D.46192 + 64888;
    if (D.46197 > 9) goto <D.46410>; else goto <D.46411>;
    <D.46410>:
    D.46095 = cfg->cbb;
    mono_link_bblock (cfg, D.46095, is_ref_bb);
    <D.46411>:
    <D.46405>:
    D.46095 = cfg->cbb;
    D.46095->next_bb = is_ref_bb;
    cfg->cbb = is_ref_bb;
    D.46417 = alloc_ireg (cfg);
    addr_reg = (int) D.46417;
    val.397 = val;
    D.46319 = val.397->dreg;
    D.46419 = (unsigned int) D.46319;
    D.46420 = cfg->vreg_to_inst_len;
    if (D.46419 < D.46420) goto <D.46421>; else goto <D.46422>;
    <D.46421>:
    D.46423 = cfg->vreg_to_inst;
    val.397 = val;
    D.46319 = val.397->dreg;
    D.46424 = (long unsigned int) D.46319;
    D.46425 = D.46424 * 8;
    D.46426 = D.46423 + D.46425;
    iftmp.398 = *D.46426;
    goto <D.46427>;
    <D.46422>:
    iftmp.398 = 0B;
    <D.46427>:
    src_var = iftmp.398;
    if (src_var == 0B) goto <D.46428>; else goto <D.46429>;
    <D.46428>:
    D.46313 = &klass->byval_arg;
    val.397 = val;
    D.46319 = val.397->dreg;
    src_var = mono_compile_create_var_for_vreg (cfg, D.46313, 329, D.46319);
    <D.46429>:
    D.46120 = cfg->mempool;
    addr = mono_mempool_alloc (D.46120, 80);
    addr->data.op[1].const_val = 0;
    D.46430 = addr->data.op[1].const_val;
    addr->data.op[0].const_val = D.46430;
    addr->prev = 0B;
    D.46431 = addr->prev;
    addr->next = D.46431;
    addr->opcode = 314;
    addr->flags = 0;
    addr->type = 0;
    addr->dreg = -1;
    addr->sreg3 = -1;
    D.46432 = addr->sreg3;
    addr->sreg2 = D.46432;
    D.46433 = addr->sreg2;
    addr->sreg1 = D.46433;
    D.46131 = cfg->ip;
    addr->cil_code = D.46131;
    addr->data.op[0].p = src_var;
    D.46434 = src_var->flags;
    D.46435 = D.46434 | 16;
    src_var->flags = D.46435;
    addr->type = 5;
    D.46436 = src_var->klass;
    addr->klass = D.46436;
    D.46437 = alloc_dreg (cfg, 5);
    D.46438 = (int) D.46437;
    addr->dreg = D.46438;
    cfg->has_indirection = 1;
    D.46439 = cfg->gsharedvt;
    D.46440 = D.46439 != 0;
    D.46441 = (long int) D.46440;
    D.46442 = __builtin_expect (D.46441, 0);
    if (D.46442 != 0) goto <D.46443>; else goto <D.46444>;
    <D.46443>:
    D.46445 = src_var->data.op[1].vtype;
    D.46446 = mini_is_gsharedvt_variable_type (cfg, D.46445);
    if (D.46446 != 0) goto <D.46447>; else goto <D.46448>;
    <D.46447>:
    handle_gsharedvt_ldaddr (cfg);
    <D.46448>:
    <D.46444>:
    if (0 != 0) goto <D.46449>; else goto <D.46450>;
    <D.46449>:
    {
      struct MonoInst * var1;
      struct MonoInst * var2;

      D.46452 = src_var->dreg;
      D.46453 = D.46452 + 1;
      D.46454 = (unsigned int) D.46453;
      D.46420 = cfg->vreg_to_inst_len;
      if (D.46454 < D.46420) goto <D.46455>; else goto <D.46456>;
      <D.46455>:
      D.46423 = cfg->vreg_to_inst;
      D.46452 = src_var->dreg;
      D.46457 = (sizetype) D.46452;
      D.46458 = D.46457 + 1;
      D.46459 = D.46458 * 8;
      D.46460 = D.46423 + D.46459;
      iftmp.399 = *D.46460;
      goto <D.46461>;
      <D.46456>:
      iftmp.399 = 0B;
      <D.46461>:
      var1 = iftmp.399;
      D.46452 = src_var->dreg;
      D.46463 = D.46452 + 2;
      D.46464 = (unsigned int) D.46463;
      D.46420 = cfg->vreg_to_inst_len;
      if (D.46464 < D.46420) goto <D.46465>; else goto <D.46466>;
      <D.46465>:
      D.46423 = cfg->vreg_to_inst;
      D.46452 = src_var->dreg;
      D.46457 = (sizetype) D.46452;
      D.46467 = D.46457 + 2;
      D.46468 = D.46467 * 8;
      D.46469 = D.46423 + D.46468;
      iftmp.400 = *D.46469;
      goto <D.46470>;
      <D.46466>:
      iftmp.400 = 0B;
      <D.46470>:
      var2 = iftmp.400;
      D.46471 = var1 == 0B;
      D.46472 = (long int) D.46471;
      D.46473 = __builtin_expect (D.46472, 0);
      if (D.46473 != 0) goto <D.46474>; else goto <D.46475>;
      <D.46474>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3880, "var1");
      <D.46475>:
      D.46476 = var2 == 0B;
      D.46477 = (long int) D.46476;
      D.46478 = __builtin_expect (D.46477, 0);
      if (D.46478 != 0) goto <D.46479>; else goto <D.46480>;
      <D.46479>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3880, "var2");
      <D.46480>:
      D.46481 = var1->flags;
      D.46482 = D.46481 | 16;
      var1->flags = D.46482;
      D.46483 = var2->flags;
      D.46484 = D.46483 | 16;
      var2->flags = D.46484;
    }
    <D.46450>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    if (D.46138 != 0B) goto <D.46485>; else goto <D.46486>;
    <D.46485>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46138->next = addr;
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    addr->prev = D.46138;
    D.46095 = cfg->cbb;
    D.46095->last_ins = addr;
    goto <D.46487>;
    <D.46486>:
    D.46095 = cfg->cbb;
    D.46095 = cfg->cbb;
    D.46095->last_ins = addr;
    D.46138 = D.46095->last_ins;
    D.46095->code = D.46138;
    <D.46487>:
    {
      struct MonoInst * inst;

      D.46120 = cfg->mempool;
      inst = mono_mempool_alloc (D.46120, 80);
      inst->data.op[1].const_val = 0;
      D.46488 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.46488;
      inst->prev = 0B;
      D.46489 = inst->prev;
      inst->next = D.46489;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.46490 = inst->sreg3;
      inst->sreg2 = D.46490;
      D.46491 = inst->sreg2;
      inst->sreg1 = D.46491;
      D.46131 = cfg->ip;
      inst->cil_code = D.46131;
      inst->dreg = dreg;
      D.46492 = addr->dreg;
      inst->sreg1 = D.46492;
      inst->data.op[0].const_val = 0;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46493>; else goto <D.46494>;
      <D.46493>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46138->next = inst;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      inst->prev = D.46138;
      D.46095 = cfg->cbb;
      D.46095->last_ins = inst;
      goto <D.46495>;
      <D.46494>:
      D.46095 = cfg->cbb;
      D.46095 = cfg->cbb;
      D.46095->last_ins = inst;
      D.46138 = D.46095->last_ins;
      D.46095->code = D.46138;
      <D.46495>:
    }
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.46120 = cfg->mempool;
      ins = mono_mempool_alloc (D.46120, 80);
      ins->data.op[1].const_val = 0;
      D.46496 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.46496;
      ins->prev = 0B;
      D.46497 = ins->prev;
      ins->next = D.46497;
      ins->opcode = 442;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.46498 = ins->sreg3;
      ins->sreg2 = D.46498;
      D.46499 = ins->sreg2;
      ins->sreg1 = D.46499;
      D.46131 = cfg->ip;
      ins->cil_code = D.46131;
      if (1 != 0) goto <D.46500>; else goto <D.46501>;
      <D.46500>:
      D.46120 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.46120, 296);
      D.46146 = cfg->num_bblocks;
      D.46502 = D.46146;
      D.46503 = D.46502 + 1;
      cfg->num_bblocks = D.46503;
      D.46504 = (int) D.46502;
      falsebb->block_num = D.46504;
      ins->data.op[0].target_block = end_bb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, end_bb);
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46505>; else goto <D.46506>;
      <D.46505>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46138->next = ins;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      ins->prev = D.46138;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      goto <D.46507>;
      <D.46506>:
      D.46095 = cfg->cbb;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      D.46138 = D.46095->last_ins;
      D.46095->code = D.46138;
      <D.46507>:
      D.46508 = falsebb->cil_code;
      if (D.46508 != 0B) goto <D.46509>; else goto <D.46510>;
      <D.46509>:
      D.46179 = cfg->cil_offset_to_bb;
      D.46508 = falsebb->cil_code;
      D.46511 = (long int) D.46508;
      D.46181 = cfg->cil_start;
      D.46182 = (long int) D.46181;
      D.46512 = D.46511 - D.46182;
      D.46513 = (long unsigned int) D.46512;
      D.46514 = D.46513 * 8;
      D.46515 = D.46179 + D.46514;
      *D.46515 = falsebb;
      <D.46510>:
      D.46187 = cfg->real_offset;
      falsebb->real_offset = D.46187;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46519>; else goto <D.46516>;
      <D.46519>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 <= 9) goto <D.46517>; else goto <D.46520>;
      <D.46520>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 <= 9) goto <D.46517>; else goto <D.46521>;
      <D.46521>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 <= 9) goto <D.46517>; else goto <D.46516>;
      <D.46517>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      D.46200 = *D.46199;
      if (D.46200 == 0B) goto <D.46522>; else goto <D.46516>;
      <D.46522>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      *D.46199 = falsebb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      goto <D.46518>;
      <D.46516>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 == 0B) goto <D.46523>; else goto <D.46525>;
      <D.46525>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 442) goto <D.46526>; else goto <D.46524>;
      <D.46526>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 759) goto <D.46527>; else goto <D.46524>;
      <D.46527>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 > 9) goto <D.46528>; else goto <D.46524>;
      <D.46528>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 > 9) goto <D.46529>; else goto <D.46524>;
      <D.46529>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 > 9) goto <D.46523>; else goto <D.46524>;
      <D.46523>:
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      <D.46524>:
      <D.46518>:
      D.46095 = cfg->cbb;
      D.46095->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.46530>;
      <D.46501>:
      D.46120 = cfg->mempool;
      D.46531 = mono_mempool_alloc (D.46120, 16);
      ins->data.op[1].many_blocks = D.46531;
      D.46532 = ins->data.op[1].many_blocks;
      *D.46532 = end_bb;
      D.46532 = ins->data.op[1].many_blocks;
      D.46533 = D.46532 + 8;
      *D.46533 = 0B;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, end_bb);
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46534>; else goto <D.46535>;
      <D.46534>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46138->next = ins;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      ins->prev = D.46138;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      goto <D.46536>;
      <D.46535>:
      D.46095 = cfg->cbb;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      D.46138 = D.46095->last_ins;
      D.46095->code = D.46138;
      <D.46536>:
      D.46124 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.46216 = D.46124 & 268435456;
      if (D.46216 == 0) goto <D.46537>; else goto <D.46538>;
      <D.46537>:
      D.46120 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.46120, 296);
      D.46146 = cfg->num_bblocks;
      D.46539 = D.46146;
      D.46540 = D.46539 + 1;
      cfg->num_bblocks = D.46540;
      D.46541 = (int) D.46539;
      falsebb->block_num = D.46541;
      D.46532 = ins->data.op[1].many_blocks;
      D.46533 = D.46532 + 8;
      *D.46533 = falsebb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      D.46508 = falsebb->cil_code;
      if (D.46508 != 0B) goto <D.46542>; else goto <D.46543>;
      <D.46542>:
      D.46179 = cfg->cil_offset_to_bb;
      D.46508 = falsebb->cil_code;
      D.46511 = (long int) D.46508;
      D.46181 = cfg->cil_start;
      D.46182 = (long int) D.46181;
      D.46512 = D.46511 - D.46182;
      D.46513 = (long unsigned int) D.46512;
      D.46514 = D.46513 * 8;
      D.46515 = D.46179 + D.46514;
      *D.46515 = falsebb;
      <D.46543>:
      D.46187 = cfg->real_offset;
      falsebb->real_offset = D.46187;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46547>; else goto <D.46544>;
      <D.46547>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 <= 9) goto <D.46545>; else goto <D.46548>;
      <D.46548>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 <= 9) goto <D.46545>; else goto <D.46549>;
      <D.46549>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 <= 9) goto <D.46545>; else goto <D.46544>;
      <D.46545>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      D.46200 = *D.46199;
      if (D.46200 == 0B) goto <D.46550>; else goto <D.46544>;
      <D.46550>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      *D.46199 = falsebb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      goto <D.46546>;
      <D.46544>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 == 0B) goto <D.46551>; else goto <D.46553>;
      <D.46553>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 442) goto <D.46554>; else goto <D.46552>;
      <D.46554>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 759) goto <D.46555>; else goto <D.46552>;
      <D.46555>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 > 9) goto <D.46556>; else goto <D.46552>;
      <D.46556>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 > 9) goto <D.46557>; else goto <D.46552>;
      <D.46557>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 > 9) goto <D.46551>; else goto <D.46552>;
      <D.46551>:
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      <D.46552>:
      <D.46546>:
      D.46095 = cfg->cbb;
      D.46095->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.46558>;
      <D.46538>:
      D.46095 = cfg->cbb;
      D.46095->extended = 1;
      <D.46558>:
      <D.46530>:
    }
    D.46559 = is_nullable_bb->cil_code;
    if (D.46559 != 0B) goto <D.46560>; else goto <D.46561>;
    <D.46560>:
    D.46179 = cfg->cil_offset_to_bb;
    D.46559 = is_nullable_bb->cil_code;
    D.46562 = (long int) D.46559;
    D.46181 = cfg->cil_start;
    D.46182 = (long int) D.46181;
    D.46563 = D.46562 - D.46182;
    D.46564 = (long unsigned int) D.46563;
    D.46565 = D.46564 * 8;
    D.46566 = D.46179 + D.46565;
    *D.46566 = is_nullable_bb;
    <D.46561>:
    D.46187 = cfg->real_offset;
    is_nullable_bb->real_offset = D.46187;
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    if (D.46138 != 0B) goto <D.46570>; else goto <D.46567>;
    <D.46570>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    D.46193 = D.46192 + 64985;
    if (D.46193 <= 9) goto <D.46568>; else goto <D.46571>;
    <D.46571>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    D.46195 = D.46192 + 64878;
    if (D.46195 <= 9) goto <D.46568>; else goto <D.46572>;
    <D.46572>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    D.46197 = D.46192 + 64888;
    if (D.46197 <= 9) goto <D.46568>; else goto <D.46567>;
    <D.46568>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46198 = D.46138->data.op[1].many_blocks;
    D.46199 = D.46198 + 8;
    D.46200 = *D.46199;
    if (D.46200 == 0B) goto <D.46573>; else goto <D.46567>;
    <D.46573>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46198 = D.46138->data.op[1].many_blocks;
    D.46199 = D.46198 + 8;
    *D.46199 = is_nullable_bb;
    D.46095 = cfg->cbb;
    mono_link_bblock (cfg, D.46095, is_nullable_bb);
    goto <D.46569>;
    <D.46567>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    if (D.46138 == 0B) goto <D.46574>; else goto <D.46576>;
    <D.46576>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    if (D.46192 != 442) goto <D.46577>; else goto <D.46575>;
    <D.46577>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    if (D.46192 != 759) goto <D.46578>; else goto <D.46575>;
    <D.46578>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    D.46193 = D.46192 + 64985;
    if (D.46193 > 9) goto <D.46579>; else goto <D.46575>;
    <D.46579>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    D.46195 = D.46192 + 64878;
    if (D.46195 > 9) goto <D.46580>; else goto <D.46575>;
    <D.46580>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    D.46197 = D.46192 + 64888;
    if (D.46197 > 9) goto <D.46574>; else goto <D.46575>;
    <D.46574>:
    D.46095 = cfg->cbb;
    mono_link_bblock (cfg, D.46095, is_nullable_bb);
    <D.46575>:
    <D.46569>:
    D.46095 = cfg->cbb;
    D.46095->next_bb = is_nullable_bb;
    cfg->cbb = is_nullable_bb;
    {
      struct MonoInst * addr;
      struct MonoInst * box_call;
      struct MonoMethodSignature * box_sig;

      addr = emit_get_gsharedvt_info_klass (cfg, klass, 24);
      D.46120 = cfg->mempool;
      box_sig = mono_mempool_alloc0 (D.46120, 24);
      D.46581 = mono_defaults.object_class;
      D.46582 = &D.46581->byval_arg;
      box_sig->ret = D.46582;
      box_sig->param_count = 1;
      D.46313 = &klass->byval_arg;
      box_sig->params[0] = D.46313;
      box_call = mono_emit_calli (cfg, box_sig, &val, addr, 0B, 0B);
      D.46120 = cfg->mempool;
      res = mono_mempool_alloc (D.46120, 80);
      res->data.op[1].const_val = 0;
      D.46325 = res->data.op[1].const_val;
      res->data.op[0].const_val = D.46325;
      res->prev = 0B;
      D.46326 = res->prev;
      res->next = D.46326;
      res->opcode = 424;
      res->flags = 0;
      res->type = 0;
      res->dreg = -1;
      res->sreg3 = -1;
      D.46327 = res->sreg3;
      res->sreg2 = D.46327;
      D.46328 = res->sreg2;
      res->sreg1 = D.46328;
      D.46131 = cfg->ip;
      res->cil_code = D.46131;
      res->dreg = dreg;
      D.46583 = box_call->dreg;
      res->sreg1 = D.46583;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46584>; else goto <D.46585>;
      <D.46584>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46138->next = res;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      res->prev = D.46138;
      D.46095 = cfg->cbb;
      D.46095->last_ins = res;
      goto <D.46586>;
      <D.46585>:
      D.46095 = cfg->cbb;
      D.46095 = cfg->cbb;
      D.46095->last_ins = res;
      D.46138 = D.46095->last_ins;
      D.46095->code = D.46138;
      <D.46586>:
      res->type = 6;
      res->klass = klass;
    }
    {
      struct MonoInst * ins;
      struct MonoBasicBlock * falsebb;

      D.46120 = cfg->mempool;
      ins = mono_mempool_alloc (D.46120, 80);
      ins->data.op[1].const_val = 0;
      D.46587 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.46587;
      ins->prev = 0B;
      D.46588 = ins->prev;
      ins->next = D.46588;
      ins->opcode = 442;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.46589 = ins->sreg3;
      ins->sreg2 = D.46589;
      D.46590 = ins->sreg2;
      ins->sreg1 = D.46590;
      D.46131 = cfg->ip;
      ins->cil_code = D.46131;
      if (1 != 0) goto <D.46591>; else goto <D.46592>;
      <D.46591>:
      D.46120 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.46120, 296);
      D.46146 = cfg->num_bblocks;
      D.46593 = D.46146;
      D.46594 = D.46593 + 1;
      cfg->num_bblocks = D.46594;
      D.46595 = (int) D.46593;
      falsebb->block_num = D.46595;
      ins->data.op[0].target_block = end_bb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, end_bb);
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46596>; else goto <D.46597>;
      <D.46596>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46138->next = ins;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      ins->prev = D.46138;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      goto <D.46598>;
      <D.46597>:
      D.46095 = cfg->cbb;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      D.46138 = D.46095->last_ins;
      D.46095->code = D.46138;
      <D.46598>:
      D.46599 = falsebb->cil_code;
      if (D.46599 != 0B) goto <D.46600>; else goto <D.46601>;
      <D.46600>:
      D.46179 = cfg->cil_offset_to_bb;
      D.46599 = falsebb->cil_code;
      D.46602 = (long int) D.46599;
      D.46181 = cfg->cil_start;
      D.46182 = (long int) D.46181;
      D.46603 = D.46602 - D.46182;
      D.46604 = (long unsigned int) D.46603;
      D.46605 = D.46604 * 8;
      D.46606 = D.46179 + D.46605;
      *D.46606 = falsebb;
      <D.46601>:
      D.46187 = cfg->real_offset;
      falsebb->real_offset = D.46187;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46610>; else goto <D.46607>;
      <D.46610>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 <= 9) goto <D.46608>; else goto <D.46611>;
      <D.46611>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 <= 9) goto <D.46608>; else goto <D.46612>;
      <D.46612>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 <= 9) goto <D.46608>; else goto <D.46607>;
      <D.46608>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      D.46200 = *D.46199;
      if (D.46200 == 0B) goto <D.46613>; else goto <D.46607>;
      <D.46613>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      *D.46199 = falsebb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      goto <D.46609>;
      <D.46607>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 == 0B) goto <D.46614>; else goto <D.46616>;
      <D.46616>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 442) goto <D.46617>; else goto <D.46615>;
      <D.46617>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 759) goto <D.46618>; else goto <D.46615>;
      <D.46618>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 > 9) goto <D.46619>; else goto <D.46615>;
      <D.46619>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 > 9) goto <D.46620>; else goto <D.46615>;
      <D.46620>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 > 9) goto <D.46614>; else goto <D.46615>;
      <D.46614>:
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      <D.46615>:
      <D.46609>:
      D.46095 = cfg->cbb;
      D.46095->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.46621>;
      <D.46592>:
      D.46120 = cfg->mempool;
      D.46622 = mono_mempool_alloc (D.46120, 16);
      ins->data.op[1].many_blocks = D.46622;
      D.46623 = ins->data.op[1].many_blocks;
      *D.46623 = end_bb;
      D.46623 = ins->data.op[1].many_blocks;
      D.46624 = D.46623 + 8;
      *D.46624 = 0B;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, end_bb);
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46625>; else goto <D.46626>;
      <D.46625>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46138->next = ins;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      ins->prev = D.46138;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      goto <D.46627>;
      <D.46626>:
      D.46095 = cfg->cbb;
      D.46095 = cfg->cbb;
      D.46095->last_ins = ins;
      D.46138 = D.46095->last_ins;
      D.46095->code = D.46138;
      <D.46627>:
      D.46124 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.46216 = D.46124 & 268435456;
      if (D.46216 == 0) goto <D.46628>; else goto <D.46629>;
      <D.46628>:
      D.46120 = cfg->mempool;
      falsebb = mono_mempool_alloc0 (D.46120, 296);
      D.46146 = cfg->num_bblocks;
      D.46630 = D.46146;
      D.46631 = D.46630 + 1;
      cfg->num_bblocks = D.46631;
      D.46632 = (int) D.46630;
      falsebb->block_num = D.46632;
      D.46623 = ins->data.op[1].many_blocks;
      D.46624 = D.46623 + 8;
      *D.46624 = falsebb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      D.46599 = falsebb->cil_code;
      if (D.46599 != 0B) goto <D.46633>; else goto <D.46634>;
      <D.46633>:
      D.46179 = cfg->cil_offset_to_bb;
      D.46599 = falsebb->cil_code;
      D.46602 = (long int) D.46599;
      D.46181 = cfg->cil_start;
      D.46182 = (long int) D.46181;
      D.46603 = D.46602 - D.46182;
      D.46604 = (long unsigned int) D.46603;
      D.46605 = D.46604 * 8;
      D.46606 = D.46179 + D.46605;
      *D.46606 = falsebb;
      <D.46634>:
      D.46187 = cfg->real_offset;
      falsebb->real_offset = D.46187;
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 != 0B) goto <D.46638>; else goto <D.46635>;
      <D.46638>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 <= 9) goto <D.46636>; else goto <D.46639>;
      <D.46639>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 <= 9) goto <D.46636>; else goto <D.46640>;
      <D.46640>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 <= 9) goto <D.46636>; else goto <D.46635>;
      <D.46636>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      D.46200 = *D.46199;
      if (D.46200 == 0B) goto <D.46641>; else goto <D.46635>;
      <D.46641>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46198 = D.46138->data.op[1].many_blocks;
      D.46199 = D.46198 + 8;
      *D.46199 = falsebb;
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      goto <D.46637>;
      <D.46635>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      if (D.46138 == 0B) goto <D.46642>; else goto <D.46644>;
      <D.46644>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 442) goto <D.46645>; else goto <D.46643>;
      <D.46645>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      if (D.46192 != 759) goto <D.46646>; else goto <D.46643>;
      <D.46646>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46193 = D.46192 + 64985;
      if (D.46193 > 9) goto <D.46647>; else goto <D.46643>;
      <D.46647>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46195 = D.46192 + 64878;
      if (D.46195 > 9) goto <D.46648>; else goto <D.46643>;
      <D.46648>:
      D.46095 = cfg->cbb;
      D.46138 = D.46095->last_ins;
      D.46192 = D.46138->opcode;
      D.46197 = D.46192 + 64888;
      if (D.46197 > 9) goto <D.46642>; else goto <D.46643>;
      <D.46642>:
      D.46095 = cfg->cbb;
      mono_link_bblock (cfg, D.46095, falsebb);
      <D.46643>:
      <D.46637>:
      D.46095 = cfg->cbb;
      D.46095->next_bb = falsebb;
      cfg->cbb = falsebb;
      goto <D.46649>;
      <D.46629>:
      D.46095 = cfg->cbb;
      D.46095->extended = 1;
      <D.46649>:
      <D.46621>:
    }
    D.46650 = end_bb->cil_code;
    if (D.46650 != 0B) goto <D.46651>; else goto <D.46652>;
    <D.46651>:
    D.46179 = cfg->cil_offset_to_bb;
    D.46650 = end_bb->cil_code;
    D.46653 = (long int) D.46650;
    D.46181 = cfg->cil_start;
    D.46182 = (long int) D.46181;
    D.46654 = D.46653 - D.46182;
    D.46655 = (long unsigned int) D.46654;
    D.46656 = D.46655 * 8;
    D.46657 = D.46179 + D.46656;
    *D.46657 = end_bb;
    <D.46652>:
    D.46187 = cfg->real_offset;
    end_bb->real_offset = D.46187;
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    if (D.46138 != 0B) goto <D.46661>; else goto <D.46658>;
    <D.46661>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    D.46193 = D.46192 + 64985;
    if (D.46193 <= 9) goto <D.46659>; else goto <D.46662>;
    <D.46662>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    D.46195 = D.46192 + 64878;
    if (D.46195 <= 9) goto <D.46659>; else goto <D.46663>;
    <D.46663>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    D.46197 = D.46192 + 64888;
    if (D.46197 <= 9) goto <D.46659>; else goto <D.46658>;
    <D.46659>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46198 = D.46138->data.op[1].many_blocks;
    D.46199 = D.46198 + 8;
    D.46200 = *D.46199;
    if (D.46200 == 0B) goto <D.46664>; else goto <D.46658>;
    <D.46664>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46198 = D.46138->data.op[1].many_blocks;
    D.46199 = D.46198 + 8;
    *D.46199 = end_bb;
    D.46095 = cfg->cbb;
    mono_link_bblock (cfg, D.46095, end_bb);
    goto <D.46660>;
    <D.46658>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    if (D.46138 == 0B) goto <D.46665>; else goto <D.46667>;
    <D.46667>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    if (D.46192 != 442) goto <D.46668>; else goto <D.46666>;
    <D.46668>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    if (D.46192 != 759) goto <D.46669>; else goto <D.46666>;
    <D.46669>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    D.46193 = D.46192 + 64985;
    if (D.46193 > 9) goto <D.46670>; else goto <D.46666>;
    <D.46670>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    D.46195 = D.46192 + 64878;
    if (D.46195 > 9) goto <D.46671>; else goto <D.46666>;
    <D.46671>:
    D.46095 = cfg->cbb;
    D.46138 = D.46095->last_ins;
    D.46192 = D.46138->opcode;
    D.46197 = D.46192 + 64888;
    if (D.46197 > 9) goto <D.46665>; else goto <D.46666>;
    <D.46665>:
    D.46095 = cfg->cbb;
    mono_link_bblock (cfg, D.46095, end_bb);
    <D.46666>:
    <D.46660>:
    D.46095 = cfg->cbb;
    D.46095->next_bb = end_bb;
    cfg->cbb = end_bb;
    D.46095 = cfg->cbb;
    *out_cbb = D.46095;
    D.46102 = res;
    return D.46102;
  }
  <D.46144>:
  alloc = handle_alloc (cfg, klass, 1, context_used);
  if (alloc == 0B) goto <D.46672>; else goto <D.46673>;
  <D.46672>:
  D.46102 = 0B;
  return D.46102;
  <D.46673>:
  D.46120 = cfg->mempool;
  ins = mono_mempool_alloc (D.46120, 80);
  ins->data.op[1].const_val = 0;
  D.46311 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.46311;
  ins->prev = 0B;
  D.46312 = ins->prev;
  ins->next = D.46312;
  D.46313 = &klass->byval_arg;
  D.46674 = mono_type_to_store_membase (cfg, D.46313);
  D.46675 = (short unsigned int) D.46674;
  ins->opcode = D.46675;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.46316 = ins->sreg3;
  ins->sreg2 = D.46316;
  D.46317 = ins->sreg2;
  ins->sreg1 = D.46317;
  D.46131 = cfg->ip;
  ins->cil_code = D.46131;
  val.397 = val;
  D.46319 = val.397->dreg;
  ins->sreg1 = D.46319;
  D.46320 = alloc->dreg;
  ins->dreg = D.46320;
  ins->data.op[0].const_val = 16;
  D.46313 = &klass->byval_arg;
  type_to_eval_stack_type (cfg, D.46313, ins);
  D.46313 = &klass->byval_arg;
  D.46676 = mono_class_from_mono_type (D.46313);
  ins->klass = D.46676;
  D.46095 = cfg->cbb;
  D.46138 = D.46095->last_ins;
  if (D.46138 != 0B) goto <D.46677>; else goto <D.46678>;
  <D.46677>:
  D.46095 = cfg->cbb;
  D.46138 = D.46095->last_ins;
  D.46138->next = ins;
  D.46095 = cfg->cbb;
  D.46138 = D.46095->last_ins;
  ins->prev = D.46138;
  D.46095 = cfg->cbb;
  D.46095->last_ins = ins;
  goto <D.46679>;
  <D.46678>:
  D.46095 = cfg->cbb;
  D.46095 = cfg->cbb;
  D.46095->last_ins = ins;
  D.46138 = D.46095->last_ins;
  D.46095->code = D.46138;
  <D.46679>:
  D.46102 = alloc;
  return D.46102;
}


handle_unbox_nullable (struct MonoCompile * cfg, struct MonoInst * val, struct MonoClass * klass, int context_used)
{
  struct MonoMethod * D.46684;
  struct MonoInst * D.46685;
  struct MonoMethodSignature * D.46686;
  int pass_mrgctx.401;
  _Bool D.46688;
  long int D.46689;
  long int D.46690;
  int pass_vtable.402;
  struct MonoDomain * D.46696;
  struct MonoClass * D.46697;
  _Bool D.46698;
  long int D.46699;
  long int D.46700;
  struct MonoMemPool * D.46703;
  long int D.46704;
  struct MonoInst * D.46705;
  guint16 iftmp.403;
  long unsigned int D.46707;
  long unsigned int D.46708;
  int D.46712;
  int D.46713;
  const unsigned char * D.46714;
  void * iftmp.404;
  unsigned int D.46719;
  int D.46720;
  struct MonoBasicBlock * D.46721;
  struct MonoInst * D.46722;
  struct MonoMethod * method;

  method = mono_class_get_method_from_name (klass, "Unbox", 1);
  if (context_used != 0) goto <D.46682>; else goto <D.46683>;
  <D.46682>:
  {
    struct MonoInst * rgctx;
    struct MonoInst * addr;

    addr = emit_get_rgctx_method (cfg, context_used, method, 6);
    D.46684 = cfg->current_method;
    rgctx = emit_get_rgctx (cfg, D.46684, context_used);
    D.46686 = mono_method_signature (method);
    D.46685 = mono_emit_calli (cfg, D.46686, &val, addr, 0B, rgctx);
    return D.46685;
  }
  <D.46683>:
  {
    gboolean pass_vtable;
    gboolean pass_mrgctx;
    struct MonoInst * rgctx_arg;

    try
      {
        rgctx_arg = 0B;
        check_method_sharing (cfg, method, &pass_vtable, &pass_mrgctx);
        pass_mrgctx.401 = pass_mrgctx;
        D.46688 = pass_mrgctx.401 != 0;
        D.46689 = (long int) D.46688;
        D.46690 = __builtin_expect (D.46689, 0);
        if (D.46690 != 0) goto <D.46691>; else goto <D.46692>;
        <D.46691>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3578, "!pass_mrgctx");
        <D.46692>:
        pass_vtable.402 = pass_vtable;
        if (pass_vtable.402 != 0) goto <D.46694>; else goto <D.46695>;
        <D.46694>:
        {
          struct MonoVTable * vtable;

          D.46696 = cfg->domain;
          D.46697 = method->klass;
          vtable = mono_class_vtable (D.46696, D.46697);
          D.46698 = vtable == 0B;
          D.46699 = (long int) D.46698;
          D.46700 = __builtin_expect (D.46699, 0);
          if (D.46700 != 0) goto <D.46701>; else goto <D.46702>;
          <D.46701>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3583, "vtable");
          <D.46702>:
          D.46703 = cfg->mempool;
          rgctx_arg = mono_mempool_alloc (D.46703, 80);
          rgctx_arg->data.op[1].const_val = 0;
          D.46704 = rgctx_arg->data.op[1].const_val;
          rgctx_arg->data.op[0].const_val = D.46704;
          rgctx_arg->prev = 0B;
          D.46705 = rgctx_arg->prev;
          rgctx_arg->next = D.46705;
          D.46707 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.46708 = D.46707 & 33554432;
          if (D.46708 != 0) goto <D.46709>; else goto <D.46710>;
          <D.46709>:
          iftmp.403 = 732;
          goto <D.46711>;
          <D.46710>:
          iftmp.403 = 363;
          <D.46711>:
          rgctx_arg->opcode = iftmp.403;
          rgctx_arg->flags = 0;
          rgctx_arg->type = 0;
          rgctx_arg->dreg = -1;
          rgctx_arg->sreg3 = -1;
          D.46712 = rgctx_arg->sreg3;
          rgctx_arg->sreg2 = D.46712;
          D.46713 = rgctx_arg->sreg2;
          rgctx_arg->sreg1 = D.46713;
          D.46714 = cfg->ip;
          rgctx_arg->cil_code = D.46714;
          D.46707 = BIT_FIELD_REF <*cfg, 64, 5568>;
          D.46708 = D.46707 & 33554432;
          if (D.46708 != 0) goto <D.46716>; else goto <D.46717>;
          <D.46716>:
          iftmp.404 = vtable->klass;
          goto <D.46718>;
          <D.46717>:
          iftmp.404 = vtable;
          <D.46718>:
          rgctx_arg->data.op[0].p = iftmp.404;
          rgctx_arg->data.op[1].src = 14B;
          rgctx_arg->type = 3;
          D.46719 = alloc_dreg (cfg, 3);
          D.46720 = (int) D.46719;
          rgctx_arg->dreg = D.46720;
          D.46721 = cfg->cbb;
          D.46722 = D.46721->last_ins;
          if (D.46722 != 0B) goto <D.46723>; else goto <D.46724>;
          <D.46723>:
          D.46721 = cfg->cbb;
          D.46722 = D.46721->last_ins;
          D.46722->next = rgctx_arg;
          D.46721 = cfg->cbb;
          D.46722 = D.46721->last_ins;
          rgctx_arg->prev = D.46722;
          D.46721 = cfg->cbb;
          D.46721->last_ins = rgctx_arg;
          goto <D.46725>;
          <D.46724>:
          D.46721 = cfg->cbb;
          D.46721 = cfg->cbb;
          D.46721->last_ins = rgctx_arg;
          D.46722 = D.46721->last_ins;
          D.46721->code = D.46722;
          <D.46725>:
        }
        <D.46695>:
        D.46685 = mono_emit_method_call_full (cfg, method, 0B, 0, &val, 0B, 0B, rgctx_arg);
        return D.46685;
      }
    finally
      {
        pass_vtable = {CLOBBER};
        pass_mrgctx = {CLOBBER};
      }
  }
}


handle_unbox (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * * sp, int context_used)
{
  unsigned int D.46728;
  unsigned int D.46729;
  unsigned int D.46730;
  unsigned int D.46731;
  struct MonoInst * D.46732;
  int D.46733;
  long unsigned int D.46736;
  long unsigned int D.46737;
  struct MonoMemPool * D.46740;
  long int D.46741;
  struct MonoInst * D.46742;
  int D.46743;
  int D.46744;
  const unsigned char * D.46745;
  struct MonoBasicBlock * D.46746;
  struct MonoInst * D.46747;
  long int D.46751;
  struct MonoInst * D.46752;
  int D.46753;
  int D.46754;
  long int D.46759;
  struct MonoInst * D.46760;
  int D.46761;
  int D.46762;
  unsigned char D.46763;
  long int D.46767;
  struct MonoInst * D.46768;
  int D.46769;
  int D.46770;
  unsigned char D.46774;
  _Bool D.46775;
  long int D.46776;
  long int D.46777;
  long int D.46780;
  struct MonoInst * D.46781;
  int D.46782;
  int D.46783;
  long int D.46787;
  struct MonoInst * D.46788;
  int D.46789;
  int D.46790;
  long int D.46794;
  struct MonoInst * D.46795;
  int D.46796;
  int D.46797;
  long int D.46801;
  struct MonoInst * D.46802;
  int D.46803;
  int D.46804;
  struct MonoClass * D.46812;
  long int D.46813;
  struct MonoInst * D.46814;
  int D.46815;
  int D.46816;
  int D.46817;
  long int D.46821;
  struct MonoInst * D.46822;
  int D.46823;
  int D.46824;
  long int D.46829;
  struct MonoInst * D.46830;
  int D.46831;
  int D.46832;
  unsigned int D.46833;
  int D.46834;
  struct MonoInst * D.46838;
  struct MonoInst * add;
  int obj_reg;
  int vtable_reg;
  int klass_reg;
  int eclass_reg;
  int rank_reg;

  D.46728 = alloc_dreg (cfg, 3);
  vtable_reg = (int) D.46728;
  D.46729 = alloc_dreg (cfg, 3);
  klass_reg = (int) D.46729;
  D.46730 = alloc_dreg (cfg, 3);
  eclass_reg = (int) D.46730;
  D.46731 = alloc_dreg (cfg, 1);
  rank_reg = (int) D.46731;
  D.46732 = *sp;
  obj_reg = D.46732->dreg;
  {
    struct MonoInst * inst;
    int __ins_flags;

    __ins_flags = 32;
    D.46733 = __ins_flags & 32;
    if (D.46733 != 0) goto <D.46734>; else goto <D.46735>;
    <D.46734>:
    D.46736 = BIT_FIELD_REF <*cfg, 64, 5632>;
    D.46737 = D.46736 & 144115188075855872;
    if (D.46737 != 0) goto <D.46738>; else goto <D.46739>;
    <D.46738>:
    {
      struct MonoInst * inst;

      D.46740 = cfg->mempool;
      inst = mono_mempool_alloc (D.46740, 80);
      inst->data.op[1].const_val = 0;
      D.46741 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.46741;
      inst->prev = 0B;
      D.46742 = inst->prev;
      inst->next = D.46742;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.46743 = inst->sreg3;
      inst->sreg2 = D.46743;
      D.46744 = inst->sreg2;
      inst->sreg1 = D.46744;
      D.46745 = cfg->ip;
      inst->cil_code = D.46745;
      inst->dreg = -1;
      inst->sreg1 = obj_reg;
      inst->data.op[1].const_val = 0;
      D.46746 = cfg->cbb;
      D.46747 = D.46746->last_ins;
      if (D.46747 != 0B) goto <D.46748>; else goto <D.46749>;
      <D.46748>:
      D.46746 = cfg->cbb;
      D.46747 = D.46746->last_ins;
      D.46747->next = inst;
      D.46746 = cfg->cbb;
      D.46747 = D.46746->last_ins;
      inst->prev = D.46747;
      D.46746 = cfg->cbb;
      D.46746->last_ins = inst;
      goto <D.46750>;
      <D.46749>:
      D.46746 = cfg->cbb;
      D.46746 = cfg->cbb;
      D.46746->last_ins = inst;
      D.46747 = D.46746->last_ins;
      D.46746->code = D.46747;
      <D.46750>:
    }
    {
      struct MonoInst * inst;

      D.46740 = cfg->mempool;
      inst = mono_mempool_alloc (D.46740, 80);
      inst->data.op[1].const_val = 0;
      D.46751 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.46751;
      inst->prev = 0B;
      D.46752 = inst->prev;
      inst->next = D.46752;
      inst->opcode = 451;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.46753 = inst->sreg3;
      inst->sreg2 = D.46753;
      D.46754 = inst->sreg2;
      inst->sreg1 = D.46754;
      D.46745 = cfg->ip;
      inst->cil_code = D.46745;
      inst->data.op[1].p = "NullReferenceException";
      D.46746 = cfg->cbb;
      D.46747 = D.46746->last_ins;
      if (D.46747 != 0B) goto <D.46755>; else goto <D.46756>;
      <D.46755>:
      D.46746 = cfg->cbb;
      D.46747 = D.46746->last_ins;
      D.46747->next = inst;
      D.46746 = cfg->cbb;
      D.46747 = D.46746->last_ins;
      inst->prev = D.46747;
      D.46746 = cfg->cbb;
      D.46746->last_ins = inst;
      goto <D.46757>;
      <D.46756>:
      D.46746 = cfg->cbb;
      D.46746 = cfg->cbb;
      D.46746->last_ins = inst;
      D.46747 = D.46746->last_ins;
      D.46746->code = D.46747;
      <D.46757>:
    }
    goto <D.46758>;
    <D.46739>:
    <D.46758>:
    <D.46735>:
    D.46740 = cfg->mempool;
    inst = mono_mempool_alloc (D.46740, 80);
    inst->data.op[1].const_val = 0;
    D.46759 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.46759;
    inst->prev = 0B;
    D.46760 = inst->prev;
    inst->next = D.46760;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.46761 = inst->sreg3;
    inst->sreg2 = D.46761;
    D.46762 = inst->sreg2;
    inst->sreg1 = D.46762;
    D.46745 = cfg->ip;
    inst->cil_code = D.46745;
    inst->dreg = vtable_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 0;
    inst->type = 1;
    D.46763 = (unsigned char) __ins_flags;
    inst->flags = D.46763;
    D.46746 = cfg->cbb;
    D.46747 = D.46746->last_ins;
    if (D.46747 != 0B) goto <D.46764>; else goto <D.46765>;
    <D.46764>:
    D.46746 = cfg->cbb;
    D.46747 = D.46746->last_ins;
    D.46747->next = inst;
    D.46746 = cfg->cbb;
    D.46747 = D.46746->last_ins;
    inst->prev = D.46747;
    D.46746 = cfg->cbb;
    D.46746->last_ins = inst;
    goto <D.46766>;
    <D.46765>:
    D.46746 = cfg->cbb;
    D.46746 = cfg->cbb;
    D.46746->last_ins = inst;
    D.46747 = D.46746->last_ins;
    D.46746->code = D.46747;
    <D.46766>:
  }
  {
    struct MonoInst * inst;

    D.46740 = cfg->mempool;
    inst = mono_mempool_alloc (D.46740, 80);
    inst->data.op[1].const_val = 0;
    D.46767 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.46767;
    inst->prev = 0B;
    D.46768 = inst->prev;
    inst->next = D.46768;
    inst->opcode = 390;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.46769 = inst->sreg3;
    inst->sreg2 = D.46769;
    D.46770 = inst->sreg2;
    inst->sreg1 = D.46770;
    D.46745 = cfg->ip;
    inst->cil_code = D.46745;
    inst->dreg = rank_reg;
    inst->sreg1 = vtable_reg;
    inst->data.op[0].const_val = 42;
    D.46746 = cfg->cbb;
    D.46747 = D.46746->last_ins;
    if (D.46747 != 0B) goto <D.46771>; else goto <D.46772>;
    <D.46771>:
    D.46746 = cfg->cbb;
    D.46747 = D.46746->last_ins;
    D.46747->next = inst;
    D.46746 = cfg->cbb;
    D.46747 = D.46746->last_ins;
    inst->prev = D.46747;
    D.46746 = cfg->cbb;
    D.46746->last_ins = inst;
    goto <D.46773>;
    <D.46772>:
    D.46746 = cfg->cbb;
    D.46746 = cfg->cbb;
    D.46746->last_ins = inst;
    D.46747 = D.46746->last_ins;
    D.46746->code = D.46747;
    <D.46773>:
  }
  D.46774 = klass->rank;
  D.46775 = D.46774 != 0;
  D.46776 = (long int) D.46775;
  D.46777 = __builtin_expect (D.46776, 0);
  if (D.46777 != 0) goto <D.46778>; else goto <D.46779>;
  <D.46778>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3606, "klass->rank == 0");
  <D.46779>:
  {
    struct MonoInst * inst;

    D.46740 = cfg->mempool;
    inst = mono_mempool_alloc (D.46740, 80);
    inst->data.op[1].const_val = 0;
    D.46780 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.46780;
    inst->prev = 0B;
    D.46781 = inst->prev;
    inst->next = D.46781;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.46782 = inst->sreg3;
    inst->sreg2 = D.46782;
    D.46783 = inst->sreg2;
    inst->sreg1 = D.46783;
    D.46745 = cfg->ip;
    inst->cil_code = D.46745;
    inst->dreg = -1;
    inst->sreg1 = rank_reg;
    inst->data.op[1].const_val = 0;
    D.46746 = cfg->cbb;
    D.46747 = D.46746->last_ins;
    if (D.46747 != 0B) goto <D.46784>; else goto <D.46785>;
    <D.46784>:
    D.46746 = cfg->cbb;
    D.46747 = D.46746->last_ins;
    D.46747->next = inst;
    D.46746 = cfg->cbb;
    D.46747 = D.46746->last_ins;
    inst->prev = D.46747;
    D.46746 = cfg->cbb;
    D.46746->last_ins = inst;
    goto <D.46786>;
    <D.46785>:
    D.46746 = cfg->cbb;
    D.46746 = cfg->cbb;
    D.46746->last_ins = inst;
    D.46747 = D.46746->last_ins;
    D.46746->code = D.46747;
    <D.46786>:
  }
  {
    struct MonoInst * inst;

    D.46740 = cfg->mempool;
    inst = mono_mempool_alloc (D.46740, 80);
    inst->data.op[1].const_val = 0;
    D.46787 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.46787;
    inst->prev = 0B;
    D.46788 = inst->prev;
    inst->next = D.46788;
    inst->opcode = 456;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.46789 = inst->sreg3;
    inst->sreg2 = D.46789;
    D.46790 = inst->sreg2;
    inst->sreg1 = D.46790;
    D.46745 = cfg->ip;
    inst->cil_code = D.46745;
    inst->data.op[1].p = "InvalidCastException";
    D.46746 = cfg->cbb;
    D.46747 = D.46746->last_ins;
    if (D.46747 != 0B) goto <D.46791>; else goto <D.46792>;
    <D.46791>:
    D.46746 = cfg->cbb;
    D.46747 = D.46746->last_ins;
    D.46747->next = inst;
    D.46746 = cfg->cbb;
    D.46747 = D.46746->last_ins;
    inst->prev = D.46747;
    D.46746 = cfg->cbb;
    D.46746->last_ins = inst;
    goto <D.46793>;
    <D.46792>:
    D.46746 = cfg->cbb;
    D.46746 = cfg->cbb;
    D.46746->last_ins = inst;
    D.46747 = D.46746->last_ins;
    D.46746->code = D.46747;
    <D.46793>:
  }
  {
    struct MonoInst * inst;

    D.46740 = cfg->mempool;
    inst = mono_mempool_alloc (D.46740, 80);
    inst->data.op[1].const_val = 0;
    D.46794 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.46794;
    inst->prev = 0B;
    D.46795 = inst->prev;
    inst->next = D.46795;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.46796 = inst->sreg3;
    inst->sreg2 = D.46796;
    D.46797 = inst->sreg2;
    inst->sreg1 = D.46797;
    D.46745 = cfg->ip;
    inst->cil_code = D.46745;
    inst->dreg = klass_reg;
    inst->sreg1 = vtable_reg;
    inst->data.op[0].const_val = 0;
    D.46746 = cfg->cbb;
    D.46747 = D.46746->last_ins;
    if (D.46747 != 0B) goto <D.46798>; else goto <D.46799>;
    <D.46798>:
    D.46746 = cfg->cbb;
    D.46747 = D.46746->last_ins;
    D.46747->next = inst;
    D.46746 = cfg->cbb;
    D.46747 = D.46746->last_ins;
    inst->prev = D.46747;
    D.46746 = cfg->cbb;
    D.46746->last_ins = inst;
    goto <D.46800>;
    <D.46799>:
    D.46746 = cfg->cbb;
    D.46746 = cfg->cbb;
    D.46746->last_ins = inst;
    D.46747 = D.46746->last_ins;
    D.46746->code = D.46747;
    <D.46800>:
  }
  {
    struct MonoInst * inst;

    D.46740 = cfg->mempool;
    inst = mono_mempool_alloc (D.46740, 80);
    inst->data.op[1].const_val = 0;
    D.46801 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.46801;
    inst->prev = 0B;
    D.46802 = inst->prev;
    inst->next = D.46802;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.46803 = inst->sreg3;
    inst->sreg2 = D.46803;
    D.46804 = inst->sreg2;
    inst->sreg1 = D.46804;
    D.46745 = cfg->ip;
    inst->cil_code = D.46745;
    inst->dreg = eclass_reg;
    inst->sreg1 = klass_reg;
    inst->data.op[0].const_val = 0;
    D.46746 = cfg->cbb;
    D.46747 = D.46746->last_ins;
    if (D.46747 != 0B) goto <D.46805>; else goto <D.46806>;
    <D.46805>:
    D.46746 = cfg->cbb;
    D.46747 = D.46746->last_ins;
    D.46747->next = inst;
    D.46746 = cfg->cbb;
    D.46747 = D.46746->last_ins;
    inst->prev = D.46747;
    D.46746 = cfg->cbb;
    D.46746->last_ins = inst;
    goto <D.46807>;
    <D.46806>:
    D.46746 = cfg->cbb;
    D.46746 = cfg->cbb;
    D.46746->last_ins = inst;
    D.46747 = D.46746->last_ins;
    D.46746->code = D.46747;
    <D.46807>:
  }
  if (context_used != 0) goto <D.46808>; else goto <D.46809>;
  <D.46808>:
  {
    struct MonoInst * element_class;

    D.46774 = klass->rank;
    D.46775 = D.46774 != 0;
    D.46776 = (long int) D.46775;
    D.46777 = __builtin_expect (D.46776, 0);
    if (D.46777 != 0) goto <D.46810>; else goto <D.46811>;
    <D.46810>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 3619, "klass->rank == 0");
    <D.46811>:
    D.46812 = klass->element_class;
    element_class = emit_get_rgctx_klass (cfg, context_used, D.46812, 1);
    {
      struct MonoInst * inst;

      D.46740 = cfg->mempool;
      inst = mono_mempool_alloc (D.46740, 80);
      inst->data.op[1].const_val = 0;
      D.46813 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.46813;
      inst->prev = 0B;
      D.46814 = inst->prev;
      inst->next = D.46814;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.46815 = inst->sreg3;
      inst->sreg2 = D.46815;
      D.46816 = inst->sreg2;
      inst->sreg1 = D.46816;
      D.46745 = cfg->ip;
      inst->cil_code = D.46745;
      inst->dreg = -1;
      inst->sreg1 = eclass_reg;
      D.46817 = element_class->dreg;
      inst->sreg2 = D.46817;
      D.46746 = cfg->cbb;
      D.46747 = D.46746->last_ins;
      if (D.46747 != 0B) goto <D.46818>; else goto <D.46819>;
      <D.46818>:
      D.46746 = cfg->cbb;
      D.46747 = D.46746->last_ins;
      D.46747->next = inst;
      D.46746 = cfg->cbb;
      D.46747 = D.46746->last_ins;
      inst->prev = D.46747;
      D.46746 = cfg->cbb;
      D.46746->last_ins = inst;
      goto <D.46820>;
      <D.46819>:
      D.46746 = cfg->cbb;
      D.46746 = cfg->cbb;
      D.46746->last_ins = inst;
      D.46747 = D.46746->last_ins;
      D.46746->code = D.46747;
      <D.46820>:
    }
    {
      struct MonoInst * inst;

      D.46740 = cfg->mempool;
      inst = mono_mempool_alloc (D.46740, 80);
      inst->data.op[1].const_val = 0;
      D.46821 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.46821;
      inst->prev = 0B;
      D.46822 = inst->prev;
      inst->next = D.46822;
      inst->opcode = 456;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.46823 = inst->sreg3;
      inst->sreg2 = D.46823;
      D.46824 = inst->sreg2;
      inst->sreg1 = D.46824;
      D.46745 = cfg->ip;
      inst->cil_code = D.46745;
      inst->data.op[1].p = "InvalidCastException";
      D.46746 = cfg->cbb;
      D.46747 = D.46746->last_ins;
      if (D.46747 != 0B) goto <D.46825>; else goto <D.46826>;
      <D.46825>:
      D.46746 = cfg->cbb;
      D.46747 = D.46746->last_ins;
      D.46747->next = inst;
      D.46746 = cfg->cbb;
      D.46747 = D.46746->last_ins;
      inst->prev = D.46747;
      D.46746 = cfg->cbb;
      D.46746->last_ins = inst;
      goto <D.46827>;
      <D.46826>:
      D.46746 = cfg->cbb;
      D.46746 = cfg->cbb;
      D.46746->last_ins = inst;
      D.46747 = D.46746->last_ins;
      D.46746->code = D.46747;
      <D.46827>:
    }
  }
  goto <D.46828>;
  <D.46809>:
  D.46812 = klass->element_class;
  save_cast_details (cfg, D.46812, obj_reg, 0, 0B);
  D.46812 = klass->element_class;
  mini_emit_class_check (cfg, eclass_reg, D.46812);
  reset_cast_details (cfg);
  <D.46828>:
  D.46740 = cfg->mempool;
  add = mono_mempool_alloc (D.46740, 80);
  add->data.op[1].const_val = 0;
  D.46829 = add->data.op[1].const_val;
  add->data.op[0].const_val = D.46829;
  add->prev = 0B;
  D.46830 = add->prev;
  add->next = D.46830;
  add->opcode = 429;
  add->flags = 0;
  add->type = 0;
  add->dreg = -1;
  add->sreg3 = -1;
  D.46831 = add->sreg3;
  add->sreg2 = D.46831;
  D.46832 = add->sreg2;
  add->sreg1 = D.46832;
  D.46745 = cfg->ip;
  add->cil_code = D.46745;
  D.46833 = alloc_dreg (cfg, 5);
  D.46834 = (int) D.46833;
  add->dreg = D.46834;
  add->sreg1 = obj_reg;
  add->data.op[1].const_val = 16;
  D.46746 = cfg->cbb;
  D.46747 = D.46746->last_ins;
  if (D.46747 != 0B) goto <D.46835>; else goto <D.46836>;
  <D.46835>:
  D.46746 = cfg->cbb;
  D.46747 = D.46746->last_ins;
  D.46747->next = add;
  D.46746 = cfg->cbb;
  D.46747 = D.46746->last_ins;
  add->prev = D.46747;
  D.46746 = cfg->cbb;
  D.46746->last_ins = add;
  goto <D.46837>;
  <D.46836>:
  D.46746 = cfg->cbb;
  D.46746 = cfg->cbb;
  D.46746->last_ins = add;
  D.46747 = D.46746->last_ins;
  D.46746->code = D.46747;
  <D.46837>:
  add->type = 5;
  add->klass = klass;
  D.46838 = add;
  return D.46838;
}


ensure_method_is_allowed_to_access_field (struct MonoCompile * cfg, struct MonoMethod * caller, struct MonoClassField * field, struct MonoBasicBlock * bblock, unsigned char * ip)
{
  struct MonoMethod * D.46840;
  struct MonoException * ex;

  D.46840 = get_original_method (caller);
  ex = mono_security_core_clr_is_field_access_allowed (D.46840, field);
  if (ex != 0B) goto <D.46841>; else goto <D.46842>;
  <D.46841>:
  emit_throw_exception (cfg, ex);
  <D.46842>:
}


get_original_method (struct MonoMethod * method)
{
  long unsigned int D.46843;
  long unsigned int D.46844;
  struct MonoMethod * D.46847;

  D.46843 = BIT_FIELD_REF <*method, 64, 256>;
  D.46844 = D.46843 & 4467570830351532032;
  if (D.46844 == 0) goto <D.46845>; else goto <D.46846>;
  <D.46845>:
  D.46847 = method;
  return D.46847;
  <D.46846>:
  D.46843 = BIT_FIELD_REF <*method, 64, 256>;
  D.46844 = D.46843 & 4467570830351532032;
  if (D.46844 == 720575940379279360) goto <D.46848>; else goto <D.46849>;
  <D.46848>:
  D.46847 = 0B;
  return D.46847;
  <D.46849>:
  D.46847 = mono_marshal_method_from_wrapper (method);
  return D.46847;
}


inline_method (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, struct MonoInst * * sp, guchar * ip, guint real_offset, struct GList * dont_inline, gboolean inline_always)
{
  unsigned int D.46851;
  _Bool D.46852;
  long int D.46853;
  long int D.46854;
  int D.46859;
  int D.46862;
  struct MonoMethod * D.46865;
  int D.46866;
  unsigned int D.46869;
  char * D.46872;
  char * D.46873;
  long unsigned int D.46874;
  long unsigned int D.46875;
  int D.46878;
  int D.46879;
  struct MonoLoaderError * D.46883;
  unsigned char D.46890;
  int D.46891;
  int D.46892;
  struct MonoType * D.46895;
  int D.46896;
  struct MonoMemPool * D.46899;
  short unsigned int D.46900;
  unsigned int D.46901;
  unsigned int D.46902;
  void * D.46903;
  struct MonoInst * * D.46904;
  long unsigned int D.46905;
  long unsigned int D.46906;
  struct MonoInst * * D.46907;
  struct MonoType * D.46908;
  struct MonoInst * D.46909;
  int D.46910;
  unsigned int D.46911;
  unsigned int D.46912;
  unsigned int D.46913;
  int D.46914;
  unsigned int D.46915;
  unsigned int D.46916;
  int D.46917;
  unsigned int D.46918;
  unsigned int D.46919;
  int D.46920;
  unsigned int D.46921;
  unsigned int D.46922;
  int D.46923;
  <unnamed-unsigned:1> D.46924;
  unsigned char D.46925;
  short unsigned int D.46928;
  int D.46929;
  int D.46930;
  int prev_cil_offset_to_bb_len.405;
  unsigned char D.46934;
  <unnamed-unsigned:1> D.46935;
  unsigned int D.46936;
  unsigned int costs.406;
  char * D.46943;
  char * D.46944;
  int D.46945;
  int D.46946;
  long int D.46947;
  struct MonoInst * D.46948;
  int D.46949;
  int D.46950;
  const unsigned char * D.46951;
  struct MonoInst * D.46952;
  short int D.46956;
  struct MonoBasicBlock * * D.46959;
  struct MonoBasicBlock * D.46960;
  short int D.46961;
  short int D.46968;
  struct MonoBasicBlock * * D.46970;
  struct MonoBasicBlock * D.46971;
  short int D.46972;
  struct MonoBasicBlock * * D.46982;
  struct MonoInst * D.46983;
  short unsigned int D.46986;
  int D.46989;
  int D.46990;
  struct MonoInst * * D.46995;
  long int D.46996;
  long unsigned int D.46997;
  long unsigned int D.46998;
  struct MonoInst * * D.46999;
  struct MonoInst * D.47000;
  struct MonoType * D.47001;
  unsigned int D.47002;
  short unsigned int D.47003;
  struct MonoClass * D.47004;
  int D.47005;
  unsigned char D.47006;
  <unnamed type> D.47007;
  unsigned int D.47008;
  int D.47009;
  short unsigned int D.47010;
  struct MonoClass * D.47013;
  struct MonoBasicBlock * D.47014;
  struct MonoInst * D.47015;
  struct MonoInst * * sp.407;
  struct GSList * D.47020;
  struct GSList * D.47021;
  char * D.47024;
  struct GSList * D.47025;
  struct MonoInst * ins;
  struct MonoInst * rvar;
  struct MonoMethodHeader * cheader;
  struct MonoBasicBlock * ebblock;
  struct MonoBasicBlock * sbblock;
  int i;
  int costs;
  struct MonoMethod * prev_inlined_method;
  struct MonoInst * * prev_locals;
  struct MonoInst * * prev_args;
  struct MonoType * * prev_arg_types;
  guint prev_real_offset;
  struct GHashTable * prev_cbb_hash;
  struct MonoBasicBlock * * prev_cil_offset_to_bb;
  struct MonoBasicBlock * prev_cbb;
  unsigned char * prev_cil_start;
  guint32 prev_cil_offset_to_bb_len;
  struct MonoMethod * prev_current_method;
  struct MonoGenericContext * prev_generic_context;
  gboolean ret_var_set;
  gboolean prev_ret_var_set;
  gboolean virtual;

  rvar = 0B;
  virtual = 0;
  D.46851 = cfg->exception_type;
  D.46852 = D.46851 != 0;
  D.46853 = (long int) D.46852;
  D.46854 = __builtin_expect (D.46853, 0);
  if (D.46854 != 0) goto <D.46855>; else goto <D.46856>;
  <D.46855>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 5768, "cfg->exception_type == MONO_EXCEPTION_NONE");
  <D.46856>:
  if (inline_always == 0) goto <D.46857>; else goto <D.46858>;
  <D.46857>:
  D.46859 = check_inline_called_method_name_limit (cmethod);
  if (D.46859 == 0) goto <D.46860>; else goto <D.46861>;
  <D.46860>:
  D.46862 = 0;
  return D.46862;
  <D.46861>:
  <D.46858>:
  if (inline_always == 0) goto <D.46863>; else goto <D.46864>;
  <D.46863>:
  D.46865 = cfg->method;
  D.46866 = check_inline_caller_method_name_limit (D.46865);
  if (D.46866 == 0) goto <D.46867>; else goto <D.46868>;
  <D.46867>:
  D.46862 = 0;
  return D.46862;
  <D.46868>:
  <D.46864>:
  D.46869 = cfg->verbose_level;
  if (D.46869 > 2) goto <D.46870>; else goto <D.46871>;
  <D.46870>:
  D.46865 = cfg->method;
  D.46872 = mono_method_full_name (D.46865, 1);
  D.46873 = mono_method_full_name (cmethod, 1);
  printf ("INLINE START %p %s -> %s\n", cmethod, D.46872, D.46873);
  <D.46871>:
  D.46874 = BIT_FIELD_REF <*cmethod, 64, 256>;
  D.46875 = D.46874 & 9223372036854775808;
  if (D.46875 == 0) goto <D.46876>; else goto <D.46877>;
  <D.46876>:
  D.46878 = cfg->stat_inlineable_methods;
  D.46879 = D.46878 + 1;
  cfg->stat_inlineable_methods = D.46879;
  cmethod->inline_info = 1;
  <D.46877>:
  cheader = mono_method_get_header (cmethod);
  if (cheader == 0B) goto <D.46880>; else goto <D.46882>;
  <D.46882>:
  D.46883 = mono_loader_get_last_error ();
  if (D.46883 != 0B) goto <D.46880>; else goto <D.46881>;
  <D.46880>:
  {
    struct MonoLoaderError * error;

    error = mono_loader_get_last_error ();
    if (cheader != 0B) goto <D.46884>; else goto <D.46885>;
    <D.46884>:
    mono_metadata_free_mh (cheader);
    <D.46885>:
    if (inline_always != 0) goto <D.46886>; else goto <D.46887>;
    <D.46886>:
    if (error != 0B) goto <D.46888>; else goto <D.46889>;
    <D.46888>:
    D.46890 = error->exception_type;
    D.46891 = (int) D.46890;
    mono_cfg_set_exception (cfg, D.46891);
    <D.46889>:
    <D.46887>:
    mono_loader_clear_error ();
    D.46862 = 0;
    return D.46862;
  }
  <D.46881>:
  D.46892 = mono_compile_is_broken (cfg, cmethod, 0);
  if (D.46892 != 0) goto <D.46893>; else goto <D.46894>;
  <D.46893>:
  mono_metadata_free_mh (cheader);
  D.46862 = 0;
  return D.46862;
  <D.46894>:
  D.46895 = fsig->ret;
  D.46896 = mono_type_is_void (D.46895);
  if (D.46896 == 0) goto <D.46897>; else goto <D.46898>;
  <D.46897>:
  D.46895 = fsig->ret;
  rvar = mono_compile_create_var (cfg, D.46895, 329);
  <D.46898>:
  prev_locals = cfg->locals;
  D.46899 = cfg->mempool;
  D.46900 = cheader->num_locals;
  D.46901 = (unsigned int) D.46900;
  D.46902 = D.46901 * 8;
  D.46903 = mono_mempool_alloc0 (D.46899, D.46902);
  cfg->locals = D.46903;
  i = 0;
  goto <D.27024>;
  <D.27023>:
  D.46904 = cfg->locals;
  D.46905 = (long unsigned int) i;
  D.46906 = D.46905 * 8;
  D.46907 = D.46904 + D.46906;
  D.46908 = cheader->locals[i];
  D.46909 = mono_compile_create_var (cfg, D.46908, 329);
  *D.46907 = D.46909;
  i = i + 1;
  <D.27024>:
  D.46900 = cheader->num_locals;
  D.46910 = (int) D.46900;
  if (D.46910 > i) goto <D.27023>; else goto <D.27025>;
  <D.27025>:
  D.46899 = cfg->mempool;
  sbblock = mono_mempool_alloc0 (D.46899, 296);
  D.46911 = cfg->num_bblocks;
  D.46912 = D.46911;
  D.46913 = D.46912 + 1;
  cfg->num_bblocks = D.46913;
  D.46914 = (int) D.46912;
  sbblock->block_num = D.46914;
  sbblock->real_offset = real_offset;
  D.46899 = cfg->mempool;
  ebblock = mono_mempool_alloc0 (D.46899, 296);
  D.46911 = cfg->num_bblocks;
  D.46915 = D.46911;
  D.46916 = D.46915 + 1;
  cfg->num_bblocks = D.46916;
  D.46917 = (int) D.46915;
  ebblock->block_num = D.46917;
  D.46911 = cfg->num_bblocks;
  D.46918 = D.46911;
  D.46919 = D.46918 + 1;
  cfg->num_bblocks = D.46919;
  D.46920 = (int) D.46918;
  ebblock->block_num = D.46920;
  ebblock->real_offset = real_offset;
  prev_args = cfg->args;
  prev_arg_types = cfg->arg_types;
  prev_inlined_method = cfg->inlined_method;
  cfg->inlined_method = cmethod;
  cfg->ret_var_set = 0;
  D.46921 = cfg->inline_depth;
  D.46922 = D.46921 + 1;
  cfg->inline_depth = D.46922;
  prev_real_offset = cfg->real_offset;
  prev_cbb_hash = cfg->cbb_hash;
  prev_cil_offset_to_bb = cfg->cil_offset_to_bb;
  D.46923 = cfg->cil_offset_to_bb_len;
  prev_cil_offset_to_bb_len = (guint32) D.46923;
  prev_cil_start = cfg->cil_start;
  prev_cbb = cfg->cbb;
  prev_current_method = cfg->current_method;
  prev_generic_context = cfg->generic_context;
  D.46924 = cfg->ret_var_set;
  prev_ret_var_set = (gboolean) D.46924;
  D.46925 = *ip;
  if (D.46925 == 111) goto <D.46926>; else goto <D.46927>;
  <D.46926>:
  D.46928 = cmethod->flags;
  D.46929 = (int) D.46928;
  D.46930 = D.46929 & 16;
  if (D.46930 == 0) goto <D.46931>; else goto <D.46932>;
  <D.46931>:
  virtual = 1;
  <D.46932>:
  <D.46927>:
  costs = mono_method_to_ir (cfg, cmethod, sbblock, ebblock, rvar, dont_inline, sp, real_offset, virtual);
  D.46924 = cfg->ret_var_set;
  ret_var_set = (gboolean) D.46924;
  cfg->inlined_method = prev_inlined_method;
  cfg->real_offset = prev_real_offset;
  cfg->cbb_hash = prev_cbb_hash;
  cfg->cil_offset_to_bb = prev_cil_offset_to_bb;
  prev_cil_offset_to_bb_len.405 = (int) prev_cil_offset_to_bb_len;
  cfg->cil_offset_to_bb_len = prev_cil_offset_to_bb_len.405;
  cfg->cil_start = prev_cil_start;
  cfg->locals = prev_locals;
  cfg->args = prev_args;
  cfg->arg_types = prev_arg_types;
  cfg->current_method = prev_current_method;
  cfg->generic_context = prev_generic_context;
  D.46934 = (unsigned char) prev_ret_var_set;
  D.46935 = (<unnamed-unsigned:1>) D.46934;
  cfg->ret_var_set = D.46935;
  D.46921 = cfg->inline_depth;
  D.46936 = D.46921 + 4294967295;
  cfg->inline_depth = D.46936;
  costs.406 = (unsigned int) costs;
  if (costs.406 <= 59) goto <D.46937>; else goto <D.46940>;
  <D.46940>:
  if (inline_always != 0) goto <D.46937>; else goto <D.46938>;
  <D.46937>:
  D.46869 = cfg->verbose_level;
  if (D.46869 > 2) goto <D.46941>; else goto <D.46942>;
  <D.46941>:
  D.46865 = cfg->method;
  D.46943 = mono_method_full_name (D.46865, 1);
  D.46944 = mono_method_full_name (cmethod, 1);
  printf ("INLINE END %s -> %s\n", D.46943, D.46944);
  <D.46942>:
  D.46945 = cfg->stat_inlined_methods;
  D.46946 = D.46945 + 1;
  cfg->stat_inlined_methods = D.46946;
  D.46899 = cfg->mempool;
  ins = mono_mempool_alloc (D.46899, 80);
  ins->data.op[1].const_val = 0;
  D.46947 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.46947;
  ins->prev = 0B;
  D.46948 = ins->prev;
  ins->next = D.46948;
  ins->opcode = 316;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.46949 = ins->sreg3;
  ins->sreg2 = D.46949;
  D.46950 = ins->sreg2;
  ins->sreg1 = D.46950;
  D.46951 = cfg->ip;
  ins->cil_code = D.46951;
  D.46952 = prev_cbb->last_ins;
  if (D.46952 != 0B) goto <D.46953>; else goto <D.46954>;
  <D.46953>:
  D.46952 = prev_cbb->last_ins;
  D.46952->next = ins;
  D.46952 = prev_cbb->last_ins;
  ins->prev = D.46952;
  prev_cbb->last_ins = ins;
  goto <D.46955>;
  <D.46954>:
  prev_cbb->last_ins = ins;
  D.46952 = prev_cbb->last_ins;
  prev_cbb->code = D.46952;
  <D.46955>:
  prev_cbb->next_bb = sbblock;
  link_bblock (cfg, prev_cbb, sbblock);
  mono_merge_basic_blocks (cfg, prev_cbb, sbblock);
  D.46956 = prev_cbb->out_count;
  if (D.46956 == 1) goto <D.46957>; else goto <D.46958>;
  <D.46957>:
  D.46959 = prev_cbb->out_bb;
  D.46960 = *D.46959;
  D.46961 = D.46960->in_count;
  if (D.46961 == 1) goto <D.46962>; else goto <D.46963>;
  <D.46962>:
  D.46959 = prev_cbb->out_bb;
  D.46960 = *D.46959;
  if (D.46960 != ebblock) goto <D.46964>; else goto <D.46965>;
  <D.46964>:
  D.46959 = prev_cbb->out_bb;
  D.46960 = *D.46959;
  mono_merge_basic_blocks (cfg, prev_cbb, D.46960);
  <D.46965>:
  <D.46963>:
  <D.46958>:
  D.46968 = ebblock->in_count;
  if (D.46968 == 1) goto <D.46969>; else goto <D.46966>;
  <D.46969>:
  D.46970 = ebblock->in_bb;
  D.46971 = *D.46970;
  D.46972 = D.46971->out_count;
  if (D.46972 == 1) goto <D.46973>; else goto <D.46966>;
  <D.46973>:
  {
    struct MonoBasicBlock * prev;

    D.46970 = ebblock->in_bb;
    prev = *D.46970;
    mono_merge_basic_blocks (cfg, prev, ebblock);
    cfg->cbb = prev;
    D.46956 = prev_cbb->out_count;
    if (D.46956 == 1) goto <D.46974>; else goto <D.46975>;
    <D.46974>:
    D.46959 = prev_cbb->out_bb;
    D.46960 = *D.46959;
    D.46961 = D.46960->in_count;
    if (D.46961 == 1) goto <D.46976>; else goto <D.46977>;
    <D.46976>:
    D.46959 = prev_cbb->out_bb;
    D.46960 = *D.46959;
    if (D.46960 == prev) goto <D.46978>; else goto <D.46979>;
    <D.46978>:
    mono_merge_basic_blocks (cfg, prev_cbb, prev);
    cfg->cbb = prev_cbb;
    <D.46979>:
    <D.46977>:
    <D.46975>:
  }
  goto <D.46967>;
  <D.46966>:
  if (rvar != 0B) goto <D.46980>; else goto <D.46981>;
  <D.46980>:
  {
    struct MonoBasicBlock * bb;

    i = 0;
    goto <D.27029>;
    <D.27028>:
    D.46970 = ebblock->in_bb;
    D.46905 = (long unsigned int) i;
    D.46906 = D.46905 * 8;
    D.46982 = D.46970 + D.46906;
    bb = *D.46982;
    D.46983 = bb->last_ins;
    if (D.46983 != 0B) goto <D.46984>; else goto <D.46985>;
    <D.46984>:
    D.46983 = bb->last_ins;
    D.46986 = D.46983->opcode;
    if (D.46986 == 798) goto <D.46987>; else goto <D.46988>;
    <D.46987>:
    cfg->cbb = bb;
    D.46989 = rvar->dreg;
    D.46895 = fsig->ret;
    emit_init_rvar (cfg, D.46989, D.46895);
    <D.46988>:
    <D.46985>:
    i = i + 1;
    <D.27029>:
    D.46968 = ebblock->in_count;
    D.46990 = (int) D.46968;
    if (D.46990 > i) goto <D.27028>; else goto <D.27030>;
    <D.27030>:
  }
  <D.46981>:
  cfg->cbb = ebblock;
  <D.46967>:
  if (rvar != 0B) goto <D.46991>; else goto <D.46992>;
  <D.46991>:
  if (ret_var_set == 0) goto <D.46993>; else goto <D.46994>;
  <D.46993>:
  D.46989 = rvar->dreg;
  D.46895 = fsig->ret;
  emit_init_rvar (cfg, D.46989, D.46895);
  <D.46994>:
  D.46899 = cfg->mempool;
  ins = mono_mempool_alloc (D.46899, 80);
  ins->data.op[1].const_val = 0;
  D.46947 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.46947;
  ins->prev = 0B;
  D.46948 = ins->prev;
  ins->next = D.46948;
  ins->opcode = 424;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.46949 = ins->sreg3;
  ins->sreg2 = D.46949;
  D.46950 = ins->sreg2;
  ins->sreg1 = D.46950;
  D.46951 = cfg->ip;
  ins->cil_code = D.46951;
  D.46995 = cfg->varinfo;
  D.46996 = rvar->data.op[0].const_val;
  D.46997 = (long unsigned int) D.46996;
  D.46998 = D.46997 * 8;
  D.46999 = D.46995 + D.46998;
  D.47000 = *D.46999;
  D.47001 = D.47000->data.op[1].vtype;
  D.47002 = mono_type_to_regmove (cfg, D.47001);
  D.47003 = (short unsigned int) D.47002;
  ins->opcode = D.47003;
  D.46995 = cfg->varinfo;
  D.46996 = rvar->data.op[0].const_val;
  D.46997 = (long unsigned int) D.46996;
  D.46998 = D.46997 * 8;
  D.46999 = D.46995 + D.46998;
  D.47000 = *D.46999;
  D.47001 = D.47000->data.op[1].vtype;
  type_to_eval_stack_type (cfg, D.47001, ins);
  D.46995 = cfg->varinfo;
  D.46996 = rvar->data.op[0].const_val;
  D.46997 = (long unsigned int) D.46996;
  D.46998 = D.46997 * 8;
  D.46999 = D.46995 + D.46998;
  D.47000 = *D.46999;
  D.47004 = D.47000->klass;
  ins->klass = D.47004;
  D.46995 = cfg->varinfo;
  D.46996 = rvar->data.op[0].const_val;
  D.46997 = (long unsigned int) D.46996;
  D.46998 = D.46997 * 8;
  D.46999 = D.46995 + D.46998;
  D.47000 = *D.46999;
  D.47005 = D.47000->dreg;
  ins->sreg1 = D.47005;
  D.47006 = ins->type;
  D.47007 = (<unnamed type>) D.47006;
  D.47008 = alloc_dreg (cfg, D.47007);
  D.47009 = (int) D.47008;
  ins->dreg = D.47009;
  D.47010 = ins->opcode;
  if (D.47010 == 427) goto <D.47011>; else goto <D.47012>;
  <D.47011>:
  D.46995 = cfg->varinfo;
  D.46996 = rvar->data.op[0].const_val;
  D.46997 = (long unsigned int) D.46996;
  D.46998 = D.46997 * 8;
  D.46999 = D.46995 + D.46998;
  D.47000 = *D.46999;
  D.47001 = D.47000->data.op[1].vtype;
  D.47013 = mono_class_from_mono_type (D.47001);
  ins->klass = D.47013;
  <D.47012>:
  D.47014 = cfg->cbb;
  D.47015 = D.47014->last_ins;
  if (D.47015 != 0B) goto <D.47016>; else goto <D.47017>;
  <D.47016>:
  D.47014 = cfg->cbb;
  D.47015 = D.47014->last_ins;
  D.47015->next = ins;
  D.47014 = cfg->cbb;
  D.47015 = D.47014->last_ins;
  ins->prev = D.47015;
  D.47014 = cfg->cbb;
  D.47014->last_ins = ins;
  goto <D.47018>;
  <D.47017>:
  D.47014 = cfg->cbb;
  D.47014 = cfg->cbb;
  D.47014->last_ins = ins;
  D.47015 = D.47014->last_ins;
  D.47014->code = D.47015;
  <D.47018>:
  sp.407 = sp;
  sp = sp.407 + 8;
  *sp.407 = ins;
  <D.46992>:
  D.46899 = cfg->mempool;
  D.47020 = cfg->headers_to_free;
  D.47021 = g_slist_prepend_mempool (D.46899, D.47020, cheader);
  cfg->headers_to_free = D.47021;
  D.46862 = costs + 1;
  return D.46862;
  <D.46938>:
  D.46869 = cfg->verbose_level;
  if (D.46869 > 2) goto <D.47022>; else goto <D.47023>;
  <D.47022>:
  D.47024 = mono_method_full_name (cmethod, 1);
  printf ("INLINE ABORTED %s (cost %d)\n", D.47024, costs);
  <D.47023>:
  cfg->exception_type = 0;
  mono_loader_clear_error ();
  cfg->cbb = prev_cbb;
  D.46899 = cfg->mempool;
  D.47020 = cfg->headers_to_free;
  D.47025 = g_slist_prepend_mempool (D.46899, D.47020, cheader);
  cfg->headers_to_free = D.47025;
  D.46862 = 0;
  return D.46862;
}


check_inline_called_method_name_limit (struct MonoMethod * called_method)
{
  const char * limit.408;
  char D.47033;
  long unsigned int D.47036;
  gboolean D.47037;
  _Bool D.47038;
  int strncmp_result;
  static const char * limit = 0B;

  limit.408 = limit;
  if (limit.408 == 0B) goto <D.47028>; else goto <D.47029>;
  <D.47028>:
  {
    const char * limit_string;

    limit_string = monoeg_g_getenv ("MONO_INLINE_CALLED_METHOD_NAME_LIMIT");
    if (limit_string != 0B) goto <D.47030>; else goto <D.47031>;
    <D.47030>:
    limit = limit_string;
    goto <D.47032>;
    <D.47031>:
    limit = "";
    <D.47032>:
  }
  <D.47029>:
  limit.408 = limit;
  D.47033 = *limit.408;
  if (D.47033 != 0) goto <D.47034>; else goto <D.47035>;
  <D.47034>:
  {
    char * called_method_name;

    called_method_name = mono_method_full_name (called_method, 1);
    limit.408 = limit;
    limit.408 = limit;
    D.47036 = __strlen_g (limit.408);
    strncmp_result = strncmp (called_method_name, limit.408, D.47036);
    monoeg_g_free (called_method_name);
    D.47038 = strncmp_result == 0;
    D.47037 = (gboolean) D.47038;
    return D.47037;
  }
  <D.47035>:
  D.47037 = 1;
  return D.47037;
}


__attribute__((__gnu_inline__))
__strlen_g (const char * __str)
{
  size_t D.47040;
  long int __ptr.409;
  long int __str.410;
  long int D.47043;
  char * __ptr;
  char * __tmp;

  __ptr = 0B;
  __tmp = __str;
  __asm__ __volatile__("   la    0,0
0: srst  %0,%1
   jo    0b
" : "=&a" __ptr, "=&a" __tmp : "0" __ptr, "1" __tmp : "0", "memory", "cc");
  __ptr.409 = (long int) __ptr;
  __str.410 = (long int) __str;
  D.47043 = __ptr.409 - __str.410;
  D.47040 = (size_t) D.47043;
  return D.47040;
}


check_inline_caller_method_name_limit (struct MonoMethod * caller_method)
{
  const char * limit.411;
  char D.47051;
  long unsigned int D.47054;
  gboolean D.47055;
  _Bool D.47056;
  int strncmp_result;
  static const char * limit = 0B;

  limit.411 = limit;
  if (limit.411 == 0B) goto <D.47046>; else goto <D.47047>;
  <D.47046>:
  {
    const char * limit_string;

    limit_string = monoeg_g_getenv ("MONO_INLINE_CALLER_METHOD_NAME_LIMIT");
    if (limit_string != 0B) goto <D.47048>; else goto <D.47049>;
    <D.47048>:
    limit = limit_string;
    goto <D.47050>;
    <D.47049>:
    limit = "";
    <D.47050>:
  }
  <D.47047>:
  limit.411 = limit;
  D.47051 = *limit.411;
  if (D.47051 != 0) goto <D.47052>; else goto <D.47053>;
  <D.47052>:
  {
    char * caller_method_name;

    caller_method_name = mono_method_full_name (caller_method, 1);
    limit.411 = limit;
    limit.411 = limit;
    D.47054 = __strlen_g (limit.411);
    strncmp_result = strncmp (caller_method_name, limit.411, D.47054);
    monoeg_g_free (caller_method_name);
    D.47056 = strncmp_result == 0;
    D.47055 = (gboolean) D.47056;
    return D.47055;
  }
  <D.47053>:
  D.47055 = 1;
  return D.47055;
}


is_magic_tls_access (struct MonoClassField * field)
{
  const char * D.47058;
  int D.47059;
  gboolean D.47062;
  struct MonoClass * D.47063;
  const char * D.47064;
  int D.47065;
  struct MonoImage * D.47068;
  struct MonoImage * D.47069;
  _Bool D.47070;

  D.47058 = field->name;
  D.47059 = strcmp (D.47058, "tlsdata");
  if (D.47059 != 0) goto <D.47060>; else goto <D.47061>;
  <D.47060>:
  D.47062 = 0;
  return D.47062;
  <D.47061>:
  D.47063 = field->parent;
  D.47064 = D.47063->name;
  D.47065 = strcmp (D.47064, "ThreadLocal`1");
  if (D.47065 != 0) goto <D.47066>; else goto <D.47067>;
  <D.47066>:
  D.47062 = 0;
  return D.47062;
  <D.47067>:
  D.47063 = field->parent;
  D.47068 = D.47063->image;
  D.47069 = mono_defaults.corlib;
  D.47070 = D.47068 == D.47069;
  D.47062 = (gboolean) D.47070;
  return D.47062;
}


create_magic_tls_access (struct MonoCompile * cfg, struct MonoClassField * tls_field, struct MonoInst * * cached_tls_addr, struct MonoInst * thread_local)
{
  struct MonoInst * D.47072;
  struct MonoMemPool * D.47075;
  long int D.47076;
  struct MonoInst * D.47077;
  int D.47078;
  int D.47079;
  const unsigned char * D.47080;
  struct MonoInst * * D.47081;
  long int D.47082;
  long unsigned int D.47083;
  long unsigned int D.47084;
  struct MonoInst * * D.47085;
  struct MonoInst * D.47086;
  struct MonoType * D.47087;
  unsigned int D.47088;
  short unsigned int D.47089;
  struct MonoClass * D.47090;
  int D.47091;
  unsigned char D.47092;
  <unnamed type> D.47093;
  unsigned int D.47094;
  int D.47095;
  short unsigned int D.47096;
  struct MonoClass * D.47099;
  struct MonoBasicBlock * D.47100;
  struct MonoInst * D.47101;
  struct MonoInst * D.47105;
  struct MonoClass * D.47106;
  long int D.47107;
  struct MonoInst * D.47108;
  struct MonoType * D.47109;
  unsigned int D.47110;
  short unsigned int D.47111;
  int D.47112;
  int D.47113;
  int D.47114;
  int D.47115;
  long int D.47116;
  unsigned char D.47117;
  <unnamed type> D.47118;
  unsigned int D.47119;
  int D.47120;
  struct MonoClass * D.47130;
  int D.47131;
  struct MonoType * D.47132;
  struct MonoClass * D.47133;
  struct MonoType * D.47134;
  long int D.47135;
  struct MonoInst * D.47136;
  int D.47137;
  int D.47138;
  long int D.47139;
  long unsigned int D.47140;
  long unsigned int D.47141;
  struct MonoInst * * D.47142;
  struct MonoInst * D.47143;
  struct MonoType * D.47144;
  unsigned int D.47145;
  short unsigned int D.47146;
  struct MonoClass * D.47147;
  int D.47148;
  int D.47149;
  short unsigned int D.47150;
  struct MonoClass * D.47153;
  unsigned int D.47157;
  short unsigned int D.47158;
  unsigned int D.47159;
  int D.47160;
  struct MonoClass * D.47163;
  struct MonoInst * load;
  struct MonoInst * addr;
  struct MonoInst * temp;
  struct MonoInst * store;
  struct MonoInst * thread_ins;
  struct MonoClassField * offset_field;

  D.47072 = *cached_tls_addr;
  if (D.47072 != 0B) goto <D.47073>; else goto <D.47074>;
  <D.47073>:
  D.47075 = cfg->mempool;
  addr = mono_mempool_alloc (D.47075, 80);
  addr->data.op[1].const_val = 0;
  D.47076 = addr->data.op[1].const_val;
  addr->data.op[0].const_val = D.47076;
  addr->prev = 0B;
  D.47077 = addr->prev;
  addr->next = D.47077;
  addr->opcode = 424;
  addr->flags = 0;
  addr->type = 0;
  addr->dreg = -1;
  addr->sreg3 = -1;
  D.47078 = addr->sreg3;
  addr->sreg2 = D.47078;
  D.47079 = addr->sreg2;
  addr->sreg1 = D.47079;
  D.47080 = cfg->ip;
  addr->cil_code = D.47080;
  D.47081 = cfg->varinfo;
  D.47072 = *cached_tls_addr;
  D.47082 = D.47072->data.op[0].const_val;
  D.47083 = (long unsigned int) D.47082;
  D.47084 = D.47083 * 8;
  D.47085 = D.47081 + D.47084;
  D.47086 = *D.47085;
  D.47087 = D.47086->data.op[1].vtype;
  D.47088 = mono_type_to_regmove (cfg, D.47087);
  D.47089 = (short unsigned int) D.47088;
  addr->opcode = D.47089;
  D.47081 = cfg->varinfo;
  D.47072 = *cached_tls_addr;
  D.47082 = D.47072->data.op[0].const_val;
  D.47083 = (long unsigned int) D.47082;
  D.47084 = D.47083 * 8;
  D.47085 = D.47081 + D.47084;
  D.47086 = *D.47085;
  D.47087 = D.47086->data.op[1].vtype;
  type_to_eval_stack_type (cfg, D.47087, addr);
  D.47081 = cfg->varinfo;
  D.47072 = *cached_tls_addr;
  D.47082 = D.47072->data.op[0].const_val;
  D.47083 = (long unsigned int) D.47082;
  D.47084 = D.47083 * 8;
  D.47085 = D.47081 + D.47084;
  D.47086 = *D.47085;
  D.47090 = D.47086->klass;
  addr->klass = D.47090;
  D.47081 = cfg->varinfo;
  D.47072 = *cached_tls_addr;
  D.47082 = D.47072->data.op[0].const_val;
  D.47083 = (long unsigned int) D.47082;
  D.47084 = D.47083 * 8;
  D.47085 = D.47081 + D.47084;
  D.47086 = *D.47085;
  D.47091 = D.47086->dreg;
  addr->sreg1 = D.47091;
  D.47092 = addr->type;
  D.47093 = (<unnamed type>) D.47092;
  D.47094 = alloc_dreg (cfg, D.47093);
  D.47095 = (int) D.47094;
  addr->dreg = D.47095;
  D.47096 = addr->opcode;
  if (D.47096 == 427) goto <D.47097>; else goto <D.47098>;
  <D.47097>:
  D.47081 = cfg->varinfo;
  D.47072 = *cached_tls_addr;
  D.47082 = D.47072->data.op[0].const_val;
  D.47083 = (long unsigned int) D.47082;
  D.47084 = D.47083 * 8;
  D.47085 = D.47081 + D.47084;
  D.47086 = *D.47085;
  D.47087 = D.47086->data.op[1].vtype;
  D.47099 = mono_class_from_mono_type (D.47087);
  addr->klass = D.47099;
  <D.47098>:
  D.47100 = cfg->cbb;
  D.47101 = D.47100->last_ins;
  if (D.47101 != 0B) goto <D.47102>; else goto <D.47103>;
  <D.47102>:
  D.47100 = cfg->cbb;
  D.47101 = D.47100->last_ins;
  D.47101->next = addr;
  D.47100 = cfg->cbb;
  D.47101 = D.47100->last_ins;
  addr->prev = D.47101;
  D.47100 = cfg->cbb;
  D.47100->last_ins = addr;
  goto <D.47104>;
  <D.47103>:
  D.47100 = cfg->cbb;
  D.47100 = cfg->cbb;
  D.47100->last_ins = addr;
  D.47101 = D.47100->last_ins;
  D.47100->code = D.47101;
  <D.47104>:
  D.47105 = addr;
  return D.47105;
  <D.47074>:
  thread_ins = mono_get_thread_intrinsic (cfg);
  D.47106 = tls_field->parent;
  offset_field = mono_class_get_field_from_name (D.47106, "tls_offset");
  D.47075 = cfg->mempool;
  load = mono_mempool_alloc (D.47075, 80);
  load->data.op[1].const_val = 0;
  D.47107 = load->data.op[1].const_val;
  load->data.op[0].const_val = D.47107;
  load->prev = 0B;
  D.47108 = load->prev;
  load->next = D.47108;
  D.47109 = offset_field->type;
  D.47110 = mono_type_to_load_membase (cfg, D.47109);
  D.47111 = (short unsigned int) D.47110;
  load->opcode = D.47111;
  load->flags = 0;
  load->type = 0;
  load->dreg = -1;
  load->sreg3 = -1;
  D.47112 = load->sreg3;
  load->sreg2 = D.47112;
  D.47113 = load->sreg2;
  load->sreg1 = D.47113;
  D.47080 = cfg->ip;
  load->cil_code = D.47080;
  load->dreg = 0;
  D.47114 = thread_local->dreg;
  load->sreg1 = D.47114;
  D.47115 = offset_field->offset;
  D.47116 = (long int) D.47115;
  load->data.op[0].const_val = D.47116;
  load->type = 1;
  D.47109 = offset_field->type;
  type_to_eval_stack_type (cfg, D.47109, load);
  D.47117 = load->type;
  D.47118 = (<unnamed type>) D.47117;
  D.47119 = alloc_dreg (cfg, D.47118);
  D.47120 = (int) D.47119;
  load->dreg = D.47120;
  D.47100 = cfg->cbb;
  D.47101 = D.47100->last_ins;
  if (D.47101 != 0B) goto <D.47121>; else goto <D.47122>;
  <D.47121>:
  D.47100 = cfg->cbb;
  D.47101 = D.47100->last_ins;
  D.47101->next = load;
  D.47100 = cfg->cbb;
  D.47101 = D.47100->last_ins;
  load->prev = D.47101;
  D.47100 = cfg->cbb;
  D.47100->last_ins = load;
  goto <D.47123>;
  <D.47122>:
  D.47100 = cfg->cbb;
  D.47100 = cfg->cbb;
  D.47100->last_ins = load;
  D.47101 = D.47100->last_ins;
  D.47100->code = D.47101;
  <D.47123>:
  if (thread_ins != 0B) goto <D.47124>; else goto <D.47125>;
  <D.47124>:
  D.47100 = cfg->cbb;
  D.47101 = D.47100->last_ins;
  if (D.47101 != 0B) goto <D.47126>; else goto <D.47127>;
  <D.47126>:
  D.47100 = cfg->cbb;
  D.47101 = D.47100->last_ins;
  D.47101->next = thread_ins;
  D.47100 = cfg->cbb;
  D.47101 = D.47100->last_ins;
  thread_ins->prev = D.47101;
  D.47100 = cfg->cbb;
  D.47100->last_ins = thread_ins;
  goto <D.47128>;
  <D.47127>:
  D.47100 = cfg->cbb;
  D.47100 = cfg->cbb;
  D.47100->last_ins = thread_ins;
  D.47101 = D.47100->last_ins;
  D.47100->code = D.47101;
  <D.47128>:
  goto <D.47129>;
  <D.47125>:
  {
    struct MonoMethod * thread_method;

    D.47130 = mono_get_thread_class ();
    thread_method = mono_class_get_method_from_name (D.47130, "CurrentInternalThread_internal", 0);
    thread_ins = mono_emit_method_call (cfg, thread_method, 0B, 0B);
  }
  <D.47129>:
  D.47131 = load->dreg;
  addr = emit_managed_static_data_access (cfg, thread_ins, D.47131);
  D.47132 = tls_field->type;
  D.47133 = mono_class_from_mono_type (D.47132);
  addr->klass = D.47133;
  addr->type = 5;
  D.47134 = type_from_stack_type (addr);
  temp = mono_compile_create_var (cfg, D.47134, 329);
  *cached_tls_addr = temp;
  D.47075 = cfg->mempool;
  store = mono_mempool_alloc (D.47075, 80);
  store->data.op[1].const_val = 0;
  D.47135 = store->data.op[1].const_val;
  store->data.op[0].const_val = D.47135;
  store->prev = 0B;
  D.47136 = store->prev;
  store->next = D.47136;
  store->opcode = 424;
  store->flags = 0;
  store->type = 0;
  store->dreg = -1;
  store->sreg3 = -1;
  D.47137 = store->sreg3;
  store->sreg2 = D.47137;
  D.47138 = store->sreg2;
  store->sreg1 = D.47138;
  D.47080 = cfg->ip;
  store->cil_code = D.47080;
  D.47081 = cfg->varinfo;
  D.47139 = temp->data.op[0].const_val;
  D.47140 = (long unsigned int) D.47139;
  D.47141 = D.47140 * 8;
  D.47142 = D.47081 + D.47141;
  D.47143 = *D.47142;
  D.47144 = D.47143->data.op[1].vtype;
  D.47145 = mono_type_to_regmove (cfg, D.47144);
  D.47146 = (short unsigned int) D.47145;
  store->opcode = D.47146;
  D.47081 = cfg->varinfo;
  D.47139 = temp->data.op[0].const_val;
  D.47140 = (long unsigned int) D.47139;
  D.47141 = D.47140 * 8;
  D.47142 = D.47081 + D.47141;
  D.47143 = *D.47142;
  D.47147 = D.47143->klass;
  store->klass = D.47147;
  D.47148 = addr->dreg;
  store->sreg1 = D.47148;
  D.47081 = cfg->varinfo;
  D.47139 = temp->data.op[0].const_val;
  D.47140 = (long unsigned int) D.47139;
  D.47141 = D.47140 * 8;
  D.47142 = D.47081 + D.47141;
  D.47143 = *D.47142;
  D.47149 = D.47143->dreg;
  store->dreg = D.47149;
  D.47150 = store->opcode;
  if (D.47150 == 427) goto <D.47151>; else goto <D.47152>;
  <D.47151>:
  D.47081 = cfg->varinfo;
  D.47139 = temp->data.op[0].const_val;
  D.47140 = (long unsigned int) D.47139;
  D.47141 = D.47140 * 8;
  D.47142 = D.47081 + D.47141;
  D.47143 = *D.47142;
  D.47144 = D.47143->data.op[1].vtype;
  D.47153 = mono_class_from_mono_type (D.47144);
  store->klass = D.47153;
  <D.47152>:
  D.47100 = cfg->cbb;
  D.47101 = D.47100->last_ins;
  if (D.47101 != 0B) goto <D.47154>; else goto <D.47155>;
  <D.47154>:
  D.47100 = cfg->cbb;
  D.47101 = D.47100->last_ins;
  D.47101->next = store;
  D.47100 = cfg->cbb;
  D.47101 = D.47100->last_ins;
  store->prev = D.47101;
  D.47100 = cfg->cbb;
  D.47100->last_ins = store;
  goto <D.47156>;
  <D.47155>:
  D.47100 = cfg->cbb;
  D.47100 = cfg->cbb;
  D.47100->last_ins = store;
  D.47101 = D.47100->last_ins;
  D.47100->code = D.47101;
  <D.47156>:
  D.47075 = cfg->mempool;
  addr = mono_mempool_alloc (D.47075, 80);
  addr->data.op[1].const_val = 0;
  D.47076 = addr->data.op[1].const_val;
  addr->data.op[0].const_val = D.47076;
  addr->prev = 0B;
  D.47077 = addr->prev;
  addr->next = D.47077;
  addr->opcode = 424;
  addr->flags = 0;
  addr->type = 0;
  addr->dreg = -1;
  addr->sreg3 = -1;
  D.47078 = addr->sreg3;
  addr->sreg2 = D.47078;
  D.47079 = addr->sreg2;
  addr->sreg1 = D.47079;
  D.47080 = cfg->ip;
  addr->cil_code = D.47080;
  D.47081 = cfg->varinfo;
  D.47139 = temp->data.op[0].const_val;
  D.47140 = (long unsigned int) D.47139;
  D.47141 = D.47140 * 8;
  D.47142 = D.47081 + D.47141;
  D.47143 = *D.47142;
  D.47144 = D.47143->data.op[1].vtype;
  D.47157 = mono_type_to_regmove (cfg, D.47144);
  D.47158 = (short unsigned int) D.47157;
  addr->opcode = D.47158;
  D.47081 = cfg->varinfo;
  D.47139 = temp->data.op[0].const_val;
  D.47140 = (long unsigned int) D.47139;
  D.47141 = D.47140 * 8;
  D.47142 = D.47081 + D.47141;
  D.47143 = *D.47142;
  D.47144 = D.47143->data.op[1].vtype;
  type_to_eval_stack_type (cfg, D.47144, addr);
  D.47081 = cfg->varinfo;
  D.47139 = temp->data.op[0].const_val;
  D.47140 = (long unsigned int) D.47139;
  D.47141 = D.47140 * 8;
  D.47142 = D.47081 + D.47141;
  D.47143 = *D.47142;
  D.47147 = D.47143->klass;
  addr->klass = D.47147;
  D.47081 = cfg->varinfo;
  D.47139 = temp->data.op[0].const_val;
  D.47140 = (long unsigned int) D.47139;
  D.47141 = D.47140 * 8;
  D.47142 = D.47081 + D.47141;
  D.47143 = *D.47142;
  D.47149 = D.47143->dreg;
  addr->sreg1 = D.47149;
  D.47092 = addr->type;
  D.47093 = (<unnamed type>) D.47092;
  D.47159 = alloc_dreg (cfg, D.47093);
  D.47160 = (int) D.47159;
  addr->dreg = D.47160;
  D.47096 = addr->opcode;
  if (D.47096 == 427) goto <D.47161>; else goto <D.47162>;
  <D.47161>:
  D.47081 = cfg->varinfo;
  D.47139 = temp->data.op[0].const_val;
  D.47140 = (long unsigned int) D.47139;
  D.47141 = D.47140 * 8;
  D.47142 = D.47081 + D.47141;
  D.47143 = *D.47142;
  D.47144 = D.47143->data.op[1].vtype;
  D.47163 = mono_class_from_mono_type (D.47144);
  addr->klass = D.47163;
  <D.47162>:
  D.47100 = cfg->cbb;
  D.47101 = D.47100->last_ins;
  if (D.47101 != 0B) goto <D.47164>; else goto <D.47165>;
  <D.47164>:
  D.47100 = cfg->cbb;
  D.47101 = D.47100->last_ins;
  D.47101->next = addr;
  D.47100 = cfg->cbb;
  D.47101 = D.47100->last_ins;
  addr->prev = D.47101;
  D.47100 = cfg->cbb;
  D.47100->last_ins = addr;
  goto <D.47166>;
  <D.47165>:
  D.47100 = cfg->cbb;
  D.47100 = cfg->cbb;
  D.47100->last_ins = addr;
  D.47101 = D.47100->last_ins;
  D.47100->code = D.47101;
  <D.47166>:
  D.47105 = addr;
  return D.47105;
}


emit_managed_static_data_access (struct MonoCompile * cfg, struct MonoInst * thread_ins, int offset_reg)
{
  unsigned int D.47168;
  struct MonoMemPool * D.47169;
  long int D.47170;
  struct MonoInst * D.47171;
  int D.47172;
  int D.47173;
  const unsigned char * D.47174;
  int D.47175;
  struct MonoBasicBlock * D.47176;
  struct MonoInst * D.47177;
  unsigned int D.47181;
  long int D.47182;
  struct MonoInst * D.47183;
  int D.47184;
  int D.47185;
  long int D.47189;
  struct MonoInst * D.47190;
  int D.47191;
  int D.47192;
  long int D.47196;
  struct MonoInst * D.47197;
  int D.47198;
  int D.47199;
  long int D.47203;
  struct MonoInst * D.47204;
  int D.47205;
  int D.47206;
  unsigned int D.47210;
  long int D.47211;
  struct MonoInst * D.47212;
  int D.47213;
  int D.47214;
  unsigned int D.47218;
  long int D.47219;
  struct MonoInst * D.47220;
  int D.47221;
  int D.47222;
  unsigned int D.47226;
  long int D.47227;
  struct MonoInst * D.47228;
  int D.47229;
  int D.47230;
  struct MonoInst * D.47234;
  struct MonoInst * addr;
  int static_data_reg;
  int array_reg;
  int dreg;
  int offset2_reg;
  int idx_reg;

  D.47168 = alloc_ireg (cfg);
  static_data_reg = (int) D.47168;
  {
    struct MonoInst * inst;

    D.47169 = cfg->mempool;
    inst = mono_mempool_alloc (D.47169, 80);
    inst->data.op[1].const_val = 0;
    D.47170 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47170;
    inst->prev = 0B;
    D.47171 = inst->prev;
    inst->next = D.47171;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47172 = inst->sreg3;
    inst->sreg2 = D.47172;
    D.47173 = inst->sreg2;
    inst->sreg1 = D.47173;
    D.47174 = cfg->ip;
    inst->cil_code = D.47174;
    inst->dreg = static_data_reg;
    D.47175 = thread_ins->dreg;
    inst->sreg1 = D.47175;
    inst->data.op[0].const_val = 96;
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    if (D.47177 != 0B) goto <D.47178>; else goto <D.47179>;
    <D.47178>:
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    D.47177->next = inst;
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    inst->prev = D.47177;
    D.47176 = cfg->cbb;
    D.47176->last_ins = inst;
    goto <D.47180>;
    <D.47179>:
    D.47176 = cfg->cbb;
    D.47176 = cfg->cbb;
    D.47176->last_ins = inst;
    D.47177 = D.47176->last_ins;
    D.47176->code = D.47177;
    <D.47180>:
  }
  D.47181 = alloc_ireg (cfg);
  idx_reg = (int) D.47181;
  {
    struct MonoInst * inst;

    D.47169 = cfg->mempool;
    inst = mono_mempool_alloc (D.47169, 80);
    inst->data.op[1].const_val = 0;
    D.47182 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47182;
    inst->prev = 0B;
    D.47183 = inst->prev;
    inst->next = D.47183;
    inst->opcode = 636;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47184 = inst->sreg3;
    inst->sreg2 = D.47184;
    D.47185 = inst->sreg2;
    inst->sreg1 = D.47185;
    D.47174 = cfg->ip;
    inst->cil_code = D.47174;
    inst->dreg = idx_reg;
    inst->sreg1 = offset_reg;
    inst->data.op[1].const_val = 24;
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    if (D.47177 != 0B) goto <D.47186>; else goto <D.47187>;
    <D.47186>:
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    D.47177->next = inst;
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    inst->prev = D.47177;
    D.47176 = cfg->cbb;
    D.47176->last_ins = inst;
    goto <D.47188>;
    <D.47187>:
    D.47176 = cfg->cbb;
    D.47176 = cfg->cbb;
    D.47176->last_ins = inst;
    D.47177 = D.47176->last_ins;
    D.47176->code = D.47177;
    <D.47188>:
  }
  {
    struct MonoInst * inst;

    D.47169 = cfg->mempool;
    inst = mono_mempool_alloc (D.47169, 80);
    inst->data.op[1].const_val = 0;
    D.47189 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47189;
    inst->prev = 0B;
    D.47190 = inst->prev;
    inst->next = D.47190;
    inst->opcode = 626;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47191 = inst->sreg3;
    inst->sreg2 = D.47191;
    D.47192 = inst->sreg2;
    inst->sreg1 = D.47192;
    D.47174 = cfg->ip;
    inst->cil_code = D.47174;
    inst->dreg = idx_reg;
    inst->sreg1 = idx_reg;
    inst->data.op[1].const_val = 1;
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    if (D.47177 != 0B) goto <D.47193>; else goto <D.47194>;
    <D.47193>:
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    D.47177->next = inst;
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    inst->prev = D.47177;
    D.47176 = cfg->cbb;
    D.47176->last_ins = inst;
    goto <D.47195>;
    <D.47194>:
    D.47176 = cfg->cbb;
    D.47176 = cfg->cbb;
    D.47176->last_ins = inst;
    D.47177 = D.47176->last_ins;
    D.47176->code = D.47177;
    <D.47195>:
  }
  {
    struct MonoInst * inst;

    D.47169 = cfg->mempool;
    inst = mono_mempool_alloc (D.47169, 80);
    inst->data.op[1].const_val = 0;
    D.47196 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47196;
    inst->prev = 0B;
    D.47197 = inst->prev;
    inst->next = D.47197;
    inst->opcode = 635;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47198 = inst->sreg3;
    inst->sreg2 = D.47198;
    D.47199 = inst->sreg2;
    inst->sreg1 = D.47199;
    D.47174 = cfg->ip;
    inst->cil_code = D.47174;
    inst->dreg = idx_reg;
    inst->sreg1 = idx_reg;
    inst->data.op[1].const_val = 3;
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    if (D.47177 != 0B) goto <D.47200>; else goto <D.47201>;
    <D.47200>:
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    D.47177->next = inst;
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    inst->prev = D.47177;
    D.47176 = cfg->cbb;
    D.47176->last_ins = inst;
    goto <D.47202>;
    <D.47201>:
    D.47176 = cfg->cbb;
    D.47176 = cfg->cbb;
    D.47176->last_ins = inst;
    D.47177 = D.47176->last_ins;
    D.47176->code = D.47177;
    <D.47202>:
  }
  {
    struct MonoInst * inst;

    D.47169 = cfg->mempool;
    inst = mono_mempool_alloc (D.47169, 80);
    inst->data.op[1].const_val = 0;
    D.47203 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47203;
    inst->prev = 0B;
    D.47204 = inst->prev;
    inst->next = D.47204;
    inst->opcode = 479;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47205 = inst->sreg3;
    inst->sreg2 = D.47205;
    D.47206 = inst->sreg2;
    inst->sreg1 = D.47206;
    D.47174 = cfg->ip;
    inst->cil_code = D.47174;
    inst->dreg = static_data_reg;
    inst->sreg1 = static_data_reg;
    inst->sreg2 = idx_reg;
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    if (D.47177 != 0B) goto <D.47207>; else goto <D.47208>;
    <D.47207>:
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    D.47177->next = inst;
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    inst->prev = D.47177;
    D.47176 = cfg->cbb;
    D.47176->last_ins = inst;
    goto <D.47209>;
    <D.47208>:
    D.47176 = cfg->cbb;
    D.47176 = cfg->cbb;
    D.47176->last_ins = inst;
    D.47177 = D.47176->last_ins;
    D.47176->code = D.47177;
    <D.47209>:
  }
  D.47210 = alloc_ireg (cfg);
  array_reg = (int) D.47210;
  {
    struct MonoInst * inst;

    D.47169 = cfg->mempool;
    inst = mono_mempool_alloc (D.47169, 80);
    inst->data.op[1].const_val = 0;
    D.47211 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47211;
    inst->prev = 0B;
    D.47212 = inst->prev;
    inst->next = D.47212;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47213 = inst->sreg3;
    inst->sreg2 = D.47213;
    D.47214 = inst->sreg2;
    inst->sreg1 = D.47214;
    D.47174 = cfg->ip;
    inst->cil_code = D.47174;
    inst->dreg = array_reg;
    inst->sreg1 = static_data_reg;
    inst->data.op[0].const_val = 0;
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    if (D.47177 != 0B) goto <D.47215>; else goto <D.47216>;
    <D.47215>:
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    D.47177->next = inst;
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    inst->prev = D.47177;
    D.47176 = cfg->cbb;
    D.47176->last_ins = inst;
    goto <D.47217>;
    <D.47216>:
    D.47176 = cfg->cbb;
    D.47176 = cfg->cbb;
    D.47176->last_ins = inst;
    D.47177 = D.47176->last_ins;
    D.47176->code = D.47177;
    <D.47217>:
  }
  D.47218 = alloc_ireg (cfg);
  offset2_reg = (int) D.47218;
  {
    struct MonoInst * inst;

    D.47169 = cfg->mempool;
    inst = mono_mempool_alloc (D.47169, 80);
    inst->data.op[1].const_val = 0;
    D.47219 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47219;
    inst->prev = 0B;
    D.47220 = inst->prev;
    inst->next = D.47220;
    inst->opcode = 632;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47221 = inst->sreg3;
    inst->sreg2 = D.47221;
    D.47222 = inst->sreg2;
    inst->sreg1 = D.47222;
    D.47174 = cfg->ip;
    inst->cil_code = D.47174;
    inst->dreg = offset2_reg;
    inst->sreg1 = offset_reg;
    inst->data.op[1].const_val = 16777215;
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    if (D.47177 != 0B) goto <D.47223>; else goto <D.47224>;
    <D.47223>:
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    D.47177->next = inst;
    D.47176 = cfg->cbb;
    D.47177 = D.47176->last_ins;
    inst->prev = D.47177;
    D.47176 = cfg->cbb;
    D.47176->last_ins = inst;
    goto <D.47225>;
    <D.47224>:
    D.47176 = cfg->cbb;
    D.47176 = cfg->cbb;
    D.47176->last_ins = inst;
    D.47177 = D.47176->last_ins;
    D.47176->code = D.47177;
    <D.47225>:
  }
  D.47226 = alloc_ireg (cfg);
  dreg = (int) D.47226;
  D.47169 = cfg->mempool;
  addr = mono_mempool_alloc (D.47169, 80);
  addr->data.op[1].const_val = 0;
  D.47227 = addr->data.op[1].const_val;
  addr->data.op[0].const_val = D.47227;
  addr->prev = 0B;
  D.47228 = addr->prev;
  addr->next = D.47228;
  addr->opcode = 479;
  addr->flags = 0;
  addr->type = 0;
  addr->dreg = -1;
  addr->sreg3 = -1;
  D.47229 = addr->sreg3;
  addr->sreg2 = D.47229;
  D.47230 = addr->sreg2;
  addr->sreg1 = D.47230;
  D.47174 = cfg->ip;
  addr->cil_code = D.47174;
  addr->dreg = dreg;
  addr->sreg1 = array_reg;
  addr->sreg2 = offset2_reg;
  D.47176 = cfg->cbb;
  D.47177 = D.47176->last_ins;
  if (D.47177 != 0B) goto <D.47231>; else goto <D.47232>;
  <D.47231>:
  D.47176 = cfg->cbb;
  D.47177 = D.47176->last_ins;
  D.47177->next = addr;
  D.47176 = cfg->cbb;
  D.47177 = D.47176->last_ins;
  addr->prev = D.47177;
  D.47176 = cfg->cbb;
  D.47176->last_ins = addr;
  goto <D.47233>;
  <D.47232>:
  D.47176 = cfg->cbb;
  D.47176 = cfg->cbb;
  D.47176->last_ins = addr;
  D.47177 = D.47176->last_ins;
  D.47176->code = D.47177;
  <D.47233>:
  D.47234 = addr;
  return D.47234;
}


emit_generic_class_init (struct MonoCompile * cfg, struct MonoClass * klass)
{
  struct MonoInst * vtable_arg.412;
  struct MonoDomain * D.47240;
  struct MonoMemPool * D.47243;
  void * vtable_arg.413;
  struct MonoInst * vtable_arg.414;
  long int D.47246;
  struct MonoInst * D.47247;
  guint16 iftmp.415;
  long unsigned int D.47249;
  long unsigned int D.47250;
  int D.47254;
  int D.47255;
  const unsigned char * D.47256;
  void * iftmp.416;
  unsigned int D.47261;
  int D.47262;
  struct MonoBasicBlock * D.47263;
  struct MonoInst * D.47264;
  struct MonoMethodSignature * helper_sig_generic_class_init_trampoline_llvm.417;
  struct MonoMethodSignature * helper_sig_generic_class_init_trampoline.418;
  int D.47273;
  struct MonoInst * vtable_arg;
  struct MonoCallInst * call;
  int context_used;

  try
    {
      context_used = mini_class_check_context_used (cfg, klass);
      if (context_used != 0) goto <D.47236>; else goto <D.47237>;
      <D.47236>:
      vtable_arg.412 = emit_get_rgctx_klass (cfg, context_used, klass, 2);
      vtable_arg = vtable_arg.412;
      goto <D.47239>;
      <D.47237>:
      {
        struct MonoVTable * vtable;

        D.47240 = cfg->domain;
        vtable = mono_class_vtable (D.47240, klass);
        if (vtable == 0B) goto <D.47241>; else goto <D.47242>;
        <D.47241>:
        return;
        <D.47242>:
        D.47243 = cfg->mempool;
        vtable_arg.413 = mono_mempool_alloc (D.47243, 80);
        vtable_arg = vtable_arg.413;
        vtable_arg.414 = vtable_arg;
        vtable_arg.414 = vtable_arg;
        vtable_arg.414->data.op[1].const_val = 0;
        D.47246 = vtable_arg.414->data.op[1].const_val;
        vtable_arg.414->data.op[0].const_val = D.47246;
        vtable_arg.414 = vtable_arg;
        vtable_arg.414 = vtable_arg;
        vtable_arg.414->prev = 0B;
        D.47247 = vtable_arg.414->prev;
        vtable_arg.414->next = D.47247;
        vtable_arg.414 = vtable_arg;
        D.47249 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.47250 = D.47249 & 33554432;
        if (D.47250 != 0) goto <D.47251>; else goto <D.47252>;
        <D.47251>:
        iftmp.415 = 732;
        goto <D.47253>;
        <D.47252>:
        iftmp.415 = 363;
        <D.47253>:
        vtable_arg.414->opcode = iftmp.415;
        vtable_arg.414 = vtable_arg;
        vtable_arg.414->flags = 0;
        vtable_arg.414 = vtable_arg;
        vtable_arg.414->type = 0;
        vtable_arg.414 = vtable_arg;
        vtable_arg.414->dreg = -1;
        vtable_arg.414 = vtable_arg;
        vtable_arg.414 = vtable_arg;
        vtable_arg.414 = vtable_arg;
        vtable_arg.414->sreg3 = -1;
        D.47254 = vtable_arg.414->sreg3;
        vtable_arg.414->sreg2 = D.47254;
        D.47255 = vtable_arg.414->sreg2;
        vtable_arg.414->sreg1 = D.47255;
        vtable_arg.414 = vtable_arg;
        D.47256 = cfg->ip;
        vtable_arg.414->cil_code = D.47256;
        vtable_arg.414 = vtable_arg;
        D.47249 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.47250 = D.47249 & 33554432;
        if (D.47250 != 0) goto <D.47258>; else goto <D.47259>;
        <D.47258>:
        iftmp.416 = vtable->klass;
        goto <D.47260>;
        <D.47259>:
        iftmp.416 = vtable;
        <D.47260>:
        vtable_arg.414->data.op[0].p = iftmp.416;
        vtable_arg.414 = vtable_arg;
        vtable_arg.414->data.op[1].src = 14B;
        vtable_arg.414 = vtable_arg;
        vtable_arg.414->type = 3;
        vtable_arg.414 = vtable_arg;
        D.47261 = alloc_dreg (cfg, 3);
        D.47262 = (int) D.47261;
        vtable_arg.414->dreg = D.47262;
        D.47263 = cfg->cbb;
        D.47264 = D.47263->last_ins;
        if (D.47264 != 0B) goto <D.47265>; else goto <D.47266>;
        <D.47265>:
        D.47263 = cfg->cbb;
        D.47264 = D.47263->last_ins;
        vtable_arg.414 = vtable_arg;
        D.47264->next = vtable_arg.414;
        vtable_arg.414 = vtable_arg;
        D.47263 = cfg->cbb;
        D.47264 = D.47263->last_ins;
        vtable_arg.414->prev = D.47264;
        D.47263 = cfg->cbb;
        vtable_arg.414 = vtable_arg;
        D.47263->last_ins = vtable_arg.414;
        goto <D.47267>;
        <D.47266>:
        D.47263 = cfg->cbb;
        D.47263 = cfg->cbb;
        vtable_arg.414 = vtable_arg;
        D.47263->last_ins = vtable_arg.414;
        D.47264 = D.47263->last_ins;
        D.47263->code = D.47264;
        <D.47267>:
      }
      <D.47239>:
      if (0 != 0) goto <D.47268>; else goto <D.47269>;
      <D.47268>:
      helper_sig_generic_class_init_trampoline_llvm.417 = helper_sig_generic_class_init_trampoline_llvm;
      call = mono_emit_abs_call (cfg, 36, 0B, helper_sig_generic_class_init_trampoline_llvm.417, &vtable_arg);
      goto <D.47271>;
      <D.47269>:
      helper_sig_generic_class_init_trampoline.418 = helper_sig_generic_class_init_trampoline;
      call = mono_emit_abs_call (cfg, 36, 0B, helper_sig_generic_class_init_trampoline.418, &vtable_arg);
      <D.47271>:
      vtable_arg.414 = vtable_arg;
      D.47273 = vtable_arg.414->dreg;
      mono_call_inst_add_outarg_reg (cfg, call, D.47273, 9, 0);
      cfg->uses_vtable_reg = 1;
    }
  finally
    {
      vtable_arg = {CLOBBER};
    }
}


mini_field_access_needs_cctor_run (struct MonoCompile * cfg, struct MonoMethod * method, struct MonoClass * klass, struct MonoVTable * vtable)
{
  long unsigned int D.47277;
  long unsigned int D.47278;
  _Bool D.47281;
  long int D.47282;
  long int D.47283;
  long unsigned int D.47286;
  long unsigned int D.47287;
  gboolean D.47290;
  unsigned int D.47291;
  unsigned int D.47292;
  struct MonoMethod * D.47295;
  int D.47298;
  short unsigned int D.47301;
  int D.47302;
  int D.47303;
  struct MonoClass * D.47306;

  D.47277 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.47278 = D.47277 & 33554432;
  if (D.47278 == 0) goto <D.47279>; else goto <D.47280>;
  <D.47279>:
  D.47281 = vtable == 0B;
  D.47282 = (long int) D.47281;
  D.47283 = __builtin_expect (D.47282, 0);
  if (D.47283 != 0) goto <D.47284>; else goto <D.47285>;
  <D.47284>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4640, "vtable");
  <D.47285>:
  D.47286 = BIT_FIELD_REF <*vtable, 64, 320>;
  D.47287 = D.47286 & 274877906944;
  if (D.47287 != 0) goto <D.47288>; else goto <D.47289>;
  <D.47288>:
  D.47290 = 0;
  return D.47290;
  <D.47289>:
  <D.47280>:
  D.47291 = klass->flags;
  D.47292 = D.47291 & 1048576;
  if (D.47292 != 0) goto <D.47293>; else goto <D.47294>;
  <D.47293>:
  D.47295 = cfg->method;
  if (D.47295 == method) goto <D.47296>; else goto <D.47297>;
  <D.47296>:
  D.47290 = 0;
  return D.47290;
  <D.47297>:
  <D.47294>:
  D.47298 = mono_class_needs_cctor_run (klass, method);
  if (D.47298 == 0) goto <D.47299>; else goto <D.47300>;
  <D.47299>:
  D.47290 = 0;
  return D.47290;
  <D.47300>:
  D.47301 = method->flags;
  D.47302 = (int) D.47301;
  D.47303 = D.47302 & 16;
  if (D.47303 == 0) goto <D.47304>; else goto <D.47305>;
  <D.47304>:
  D.47306 = method->klass;
  if (D.47306 == klass) goto <D.47307>; else goto <D.47308>;
  <D.47307>:
  D.47290 = 0;
  return D.47290;
  <D.47308>:
  <D.47305>:
  D.47290 = 1;
  return D.47290;
}


set_exception_object (struct MonoCompile * cfg, struct MonoException * exception)
{
  void * * D.47312;
  void * D.47313;

  mono_cfg_set_exception (cfg, 13);
  if (0 != 0) goto <D.47310>; else goto <D.47311>;
  <D.47310>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6342, "sizeof (cfg->exception_ptr) == sizeof (MonoObject*)");
  <D.47311>:
  D.47312 = &cfg->exception_ptr;
  D.47313 = mono_gc_make_root_descr_all_refs (1);
  mono_gc_register_root (D.47312, 8, D.47313);
  cfg->exception_ptr = exception;
}


initialize_array_data (struct MonoMethod * method, gboolean aot, unsigned char * ip, struct MonoClass * klass, guint32 len, int * out_size, guint32 * out_field_token)
{
  unsigned char D.47314;
  unsigned char * D.47317;
  unsigned char D.47318;
  unsigned char * D.47321;
  unsigned char D.47322;
  unsigned char * D.47325;
  unsigned char D.47326;
  unsigned char * D.47329;
  unsigned int D.47330;
  unsigned int D.47331;
  unsigned int D.47332;
  unsigned int D.47333;
  unsigned int D.47334;
  unsigned int D.47335;
  unsigned int D.47336;
  unsigned int D.47337;
  unsigned int D.47338;
  unsigned char * D.47339;
  unsigned int D.47340;
  unsigned int D.47341;
  unsigned int D.47342;
  unsigned int D.47343;
  unsigned int D.47344;
  unsigned int D.47345;
  unsigned int D.47346;
  unsigned int D.47347;
  unsigned int D.47348;
  struct MonoClass * D.47349;
  struct MonoImage * D.47350;
  const char * D.47353;
  const char * D.47358;
  int D.47359;
  struct MonoClass * D.47361;
  const char * D.47362;
  int D.47363;
  struct MonoImage * D.47365;
  struct MonoImage * D.47366;
  struct MonoType * D.47367;
  struct MonoType * D.47368;
  unsigned char D.47369;
  int D.47370;
  unsigned int size.419;
  unsigned int D.47372;
  struct MonoType * D.47373;
  int D.47374;
  long unsigned int D.47377;
  long unsigned int D.47378;
  unsigned int D.47381;
  unsigned int D.47382;
  unsigned int rva.420;
  long unsigned int D.47388;
  _Bool D.47390;
  long int D.47391;
  long int D.47392;

  D.47314 = *ip;
  if (D.47314 == 37) goto <D.47315>; else goto <D.47316>;
  <D.47315>:
  D.47317 = ip + 1;
  D.47318 = *D.47317;
  if (D.47318 == 208) goto <D.47319>; else goto <D.47320>;
  <D.47319>:
  D.47321 = ip + 5;
  D.47322 = *D.47321;
  if (D.47322 == 4) goto <D.47323>; else goto <D.47324>;
  <D.47323>:
  D.47325 = ip + 6;
  D.47326 = *D.47325;
  if (D.47326 == 40) goto <D.47327>; else goto <D.47328>;
  <D.47327>:
  {
    guint32 token;
    guint32 field_token;
    guint32 field_index;
    guint32 rva;
    const char * data_ptr;
    int size;
    struct MonoMethod * cmethod;
    struct MonoClass * dummy_class;
    struct MonoClassField * field;
    int dummy_align;

    try
      {
        D.47329 = ip + 7;
        D.47330 = MEM[(const guint32 *)D.47329];
        D.47331 = D.47330 << 24;
        D.47329 = ip + 7;
        D.47330 = MEM[(const guint32 *)D.47329];
        D.47332 = D.47330 >> 8;
        D.47333 = D.47332 & 65280;
        D.47334 = D.47331 | D.47333;
        D.47329 = ip + 7;
        D.47330 = MEM[(const guint32 *)D.47329];
        D.47335 = D.47330 << 8;
        D.47336 = D.47335 & 16711680;
        D.47337 = D.47334 | D.47336;
        D.47329 = ip + 7;
        D.47330 = MEM[(const guint32 *)D.47329];
        D.47338 = D.47330 >> 24;
        token = D.47337 | D.47338;
        D.47339 = ip + 2;
        D.47340 = MEM[(const guint32 *)D.47339];
        D.47341 = D.47340 << 24;
        D.47339 = ip + 2;
        D.47340 = MEM[(const guint32 *)D.47339];
        D.47342 = D.47340 >> 8;
        D.47343 = D.47342 & 65280;
        D.47344 = D.47341 | D.47343;
        D.47339 = ip + 2;
        D.47340 = MEM[(const guint32 *)D.47339];
        D.47345 = D.47340 << 8;
        D.47346 = D.47345 & 16711680;
        D.47347 = D.47344 | D.47346;
        D.47339 = ip + 2;
        D.47340 = MEM[(const guint32 *)D.47339];
        D.47348 = D.47340 >> 24;
        field_token = D.47347 | D.47348;
        field_index = field_token & 16777215;
        size = 0;
        D.47349 = method->klass;
        D.47350 = D.47349->image;
        field = mono_field_from_token (D.47350, field_token, &dummy_class, 0B);
        if (field == 0B) goto <D.47351>; else goto <D.47352>;
        <D.47351>:
        D.47353 = 0B;
        return D.47353;
        <D.47352>:
        *out_field_token = field_token;
        cmethod = mini_get_method (0B, method, token, 0B, 0B);
        if (cmethod == 0B) goto <D.47354>; else goto <D.47355>;
        <D.47354>:
        D.47353 = 0B;
        return D.47353;
        <D.47355>:
        D.47358 = cmethod->name;
        D.47359 = strcmp (D.47358, "InitializeArray");
        if (D.47359 != 0) goto <D.47356>; else goto <D.47360>;
        <D.47360>:
        D.47361 = cmethod->klass;
        D.47362 = D.47361->name;
        D.47363 = strcmp (D.47362, "RuntimeHelpers");
        if (D.47363 != 0) goto <D.47356>; else goto <D.47364>;
        <D.47364>:
        D.47361 = cmethod->klass;
        D.47365 = D.47361->image;
        D.47366 = mono_defaults.corlib;
        if (D.47365 != D.47366) goto <D.47356>; else goto <D.47357>;
        <D.47356>:
        D.47353 = 0B;
        return D.47353;
        <D.47357>:
        D.47367 = &klass->byval_arg;
        D.47368 = mono_type_get_underlying_type (D.47367);
        D.47369 = D.47368->type;
        D.47370 = (int) D.47369;
        switch (D.47370) <default: <D.27173>, case 2: <D.27169>, case 4: <D.27170>, case 5: <D.27171>>
        <D.27169>:
        <D.27170>:
        <D.27171>:
        size = 1;
        goto <D.27172>;
        <D.27173>:
        D.47353 = 0B;
        return D.47353;
        <D.27172>:
        size.419 = (unsigned int) size;
        D.47372 = size.419 * len;
        size = (int) D.47372;
        D.47373 = field->type;
        D.47374 = mono_type_size (D.47373, &dummy_align);
        if (D.47374 < size) goto <D.47375>; else goto <D.47376>;
        <D.47375>:
        D.47353 = 0B;
        return D.47353;
        <D.47376>:
        *out_size = size;
        D.47349 = method->klass;
        D.47350 = D.47349->image;
        D.47377 = BIT_FIELD_REF <*D.47350, 64, 192>;
        D.47378 = D.47377 & 268435456;
        if (D.47378 == 0) goto <D.47379>; else goto <D.47380>;
        <D.47379>:
        D.47339 = ip + 2;
        D.47340 = MEM[(const guint32 *)D.47339];
        D.47341 = D.47340 << 24;
        D.47339 = ip + 2;
        D.47340 = MEM[(const guint32 *)D.47339];
        D.47342 = D.47340 >> 8;
        D.47343 = D.47342 & 65280;
        D.47344 = D.47341 | D.47343;
        D.47339 = ip + 2;
        D.47340 = MEM[(const guint32 *)D.47339];
        D.47345 = D.47340 << 8;
        D.47346 = D.47345 & 16711680;
        D.47347 = D.47344 | D.47346;
        D.47339 = ip + 2;
        D.47340 = MEM[(const guint32 *)D.47339];
        D.47348 = D.47340 >> 24;
        D.47381 = D.47347 | D.47348;
        field_index = D.47381 & 16777215;
        D.47349 = method->klass;
        D.47350 = D.47349->image;
        D.47382 = field_index + 4294967295;
        mono_metadata_field_info (D.47350, D.47382, 0B, &rva, 0B);
        D.47349 = method->klass;
        D.47350 = D.47349->image;
        rva.420 = rva;
        data_ptr = mono_image_rva_map (D.47350, rva.420);
        if (aot != 0) goto <D.47384>; else goto <D.47385>;
        <D.47384>:
        if (data_ptr != 0B) goto <D.47386>; else goto <D.47387>;
        <D.47386>:
        rva.420 = rva;
        D.47388 = (long unsigned int) rva.420;
        D.47353 = (const char *) D.47388;
        return D.47353;
        <D.47387>:
        <D.47385>:
        goto <D.47389>;
        <D.47380>:
        D.47390 = aot != 0;
        D.47391 = (long int) D.47390;
        D.47392 = __builtin_expect (D.47391, 0);
        if (D.47392 != 0) goto <D.47393>; else goto <D.47394>;
        <D.47393>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 6312, "!aot");
        <D.47394>:
        data_ptr = mono_field_get_data (field);
        <D.47389>:
        D.47353 = data_ptr;
        return D.47353;
      }
    finally
      {
        rva = {CLOBBER};
        dummy_class = {CLOBBER};
        dummy_align = {CLOBBER};
      }
  }
  <D.47328>:
  <D.47324>:
  <D.47320>:
  <D.47316>:
  D.47353 = 0B;
  return D.47353;
}


mini_emit_check_array_type (struct MonoCompile * cfg, struct MonoInst * obj, struct MonoClass * array_class)
{
  unsigned int D.47397;
  int D.47398;
  int D.47399;
  long unsigned int D.47402;
  long unsigned int D.47403;
  struct MonoMemPool * D.47406;
  long int D.47407;
  struct MonoInst * D.47408;
  int D.47409;
  int D.47410;
  const unsigned char * D.47411;
  struct MonoBasicBlock * D.47412;
  struct MonoInst * D.47413;
  long int D.47417;
  struct MonoInst * D.47418;
  int D.47419;
  int D.47420;
  long int D.47425;
  struct MonoInst * D.47426;
  int D.47427;
  int D.47428;
  unsigned char D.47429;
  unsigned int D.47433;
  unsigned int D.47434;
  unsigned int D.47437;
  long int D.47438;
  struct MonoInst * D.47439;
  int D.47440;
  int D.47441;
  long unsigned int D.47445;
  long unsigned int D.47446;
  unsigned int D.47449;
  long int D.47450;
  struct MonoInst * D.47451;
  guint16 iftmp.421;
  int D.47456;
  int D.47457;
  long int D.47461;
  struct MonoInst * D.47462;
  int D.47463;
  int D.47464;
  long int D.47469;
  struct MonoInst * D.47470;
  int D.47471;
  int D.47472;
  long int array_class.422;
  long int D.47480;
  struct MonoInst * D.47481;
  int D.47482;
  int D.47483;
  int D.47484;
  struct MonoDomain * D.47491;
  unsigned int D.47494;
  long int D.47495;
  struct MonoInst * D.47496;
  guint16 iftmp.423;
  int D.47501;
  int D.47502;
  void * iftmp.424;
  long int D.47510;
  struct MonoInst * D.47511;
  int D.47512;
  int D.47513;
  long int D.47520;
  struct MonoInst * D.47521;
  int D.47522;
  int D.47523;
  long int vtable.425;
  long int D.47528;
  struct MonoInst * D.47529;
  int D.47530;
  int D.47531;
  int vtable_reg;
  int context_used;

  D.47397 = alloc_preg (cfg);
  vtable_reg = (int) D.47397;
  context_used = mini_class_check_context_used (cfg, array_class);
  D.47398 = obj->dreg;
  save_cast_details (cfg, array_class, D.47398, 0, 0B);
  {
    struct MonoInst * inst;
    int __ins_flags;

    __ins_flags = 32;
    D.47399 = __ins_flags & 32;
    if (D.47399 != 0) goto <D.47400>; else goto <D.47401>;
    <D.47400>:
    D.47402 = BIT_FIELD_REF <*cfg, 64, 5632>;
    D.47403 = D.47402 & 144115188075855872;
    if (D.47403 != 0) goto <D.47404>; else goto <D.47405>;
    <D.47404>:
    {
      struct MonoInst * inst;

      D.47406 = cfg->mempool;
      inst = mono_mempool_alloc (D.47406, 80);
      inst->data.op[1].const_val = 0;
      D.47407 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47407;
      inst->prev = 0B;
      D.47408 = inst->prev;
      inst->next = D.47408;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47409 = inst->sreg3;
      inst->sreg2 = D.47409;
      D.47410 = inst->sreg2;
      inst->sreg1 = D.47410;
      D.47411 = cfg->ip;
      inst->cil_code = D.47411;
      inst->dreg = -1;
      D.47398 = obj->dreg;
      inst->sreg1 = D.47398;
      inst->data.op[1].const_val = 0;
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      if (D.47413 != 0B) goto <D.47414>; else goto <D.47415>;
      <D.47414>:
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      D.47413->next = inst;
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      inst->prev = D.47413;
      D.47412 = cfg->cbb;
      D.47412->last_ins = inst;
      goto <D.47416>;
      <D.47415>:
      D.47412 = cfg->cbb;
      D.47412 = cfg->cbb;
      D.47412->last_ins = inst;
      D.47413 = D.47412->last_ins;
      D.47412->code = D.47413;
      <D.47416>:
    }
    {
      struct MonoInst * inst;

      D.47406 = cfg->mempool;
      inst = mono_mempool_alloc (D.47406, 80);
      inst->data.op[1].const_val = 0;
      D.47417 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47417;
      inst->prev = 0B;
      D.47418 = inst->prev;
      inst->next = D.47418;
      inst->opcode = 451;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47419 = inst->sreg3;
      inst->sreg2 = D.47419;
      D.47420 = inst->sreg2;
      inst->sreg1 = D.47420;
      D.47411 = cfg->ip;
      inst->cil_code = D.47411;
      inst->data.op[1].p = "NullReferenceException";
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      if (D.47413 != 0B) goto <D.47421>; else goto <D.47422>;
      <D.47421>:
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      D.47413->next = inst;
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      inst->prev = D.47413;
      D.47412 = cfg->cbb;
      D.47412->last_ins = inst;
      goto <D.47423>;
      <D.47422>:
      D.47412 = cfg->cbb;
      D.47412 = cfg->cbb;
      D.47412->last_ins = inst;
      D.47413 = D.47412->last_ins;
      D.47412->code = D.47413;
      <D.47423>:
    }
    goto <D.47424>;
    <D.47405>:
    <D.47424>:
    <D.47401>:
    D.47406 = cfg->mempool;
    inst = mono_mempool_alloc (D.47406, 80);
    inst->data.op[1].const_val = 0;
    D.47425 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47425;
    inst->prev = 0B;
    D.47426 = inst->prev;
    inst->next = D.47426;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47427 = inst->sreg3;
    inst->sreg2 = D.47427;
    D.47428 = inst->sreg2;
    inst->sreg1 = D.47428;
    D.47411 = cfg->ip;
    inst->cil_code = D.47411;
    inst->dreg = vtable_reg;
    D.47398 = obj->dreg;
    inst->sreg1 = D.47398;
    inst->data.op[0].const_val = 0;
    inst->type = 1;
    D.47429 = (unsigned char) __ins_flags;
    inst->flags = D.47429;
    D.47412 = cfg->cbb;
    D.47413 = D.47412->last_ins;
    if (D.47413 != 0B) goto <D.47430>; else goto <D.47431>;
    <D.47430>:
    D.47412 = cfg->cbb;
    D.47413 = D.47412->last_ins;
    D.47413->next = inst;
    D.47412 = cfg->cbb;
    D.47413 = D.47412->last_ins;
    inst->prev = D.47413;
    D.47412 = cfg->cbb;
    D.47412->last_ins = inst;
    goto <D.47432>;
    <D.47431>:
    D.47412 = cfg->cbb;
    D.47412 = cfg->cbb;
    D.47412->last_ins = inst;
    D.47413 = D.47412->last_ins;
    D.47412->code = D.47413;
    <D.47432>:
  }
  D.47433 = cfg->opt;
  D.47434 = D.47433 & 512;
  if (D.47434 != 0) goto <D.47435>; else goto <D.47436>;
  <D.47435>:
  {
    int class_reg;

    D.47437 = alloc_preg (cfg);
    class_reg = (int) D.47437;
    {
      struct MonoInst * inst;

      D.47406 = cfg->mempool;
      inst = mono_mempool_alloc (D.47406, 80);
      inst->data.op[1].const_val = 0;
      D.47438 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47438;
      inst->prev = 0B;
      D.47439 = inst->prev;
      inst->next = D.47439;
      inst->opcode = 388;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47440 = inst->sreg3;
      inst->sreg2 = D.47440;
      D.47441 = inst->sreg2;
      inst->sreg1 = D.47441;
      D.47411 = cfg->ip;
      inst->cil_code = D.47411;
      inst->dreg = class_reg;
      inst->sreg1 = vtable_reg;
      inst->data.op[0].const_val = 0;
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      if (D.47413 != 0B) goto <D.47442>; else goto <D.47443>;
      <D.47442>:
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      D.47413->next = inst;
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      inst->prev = D.47413;
      D.47412 = cfg->cbb;
      D.47412->last_ins = inst;
      goto <D.47444>;
      <D.47443>:
      D.47412 = cfg->cbb;
      D.47412 = cfg->cbb;
      D.47412->last_ins = inst;
      D.47413 = D.47412->last_ins;
      D.47412->code = D.47413;
      <D.47444>:
    }
    D.47445 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.47446 = D.47445 & 33554432;
    if (D.47446 != 0) goto <D.47447>; else goto <D.47448>;
    <D.47447>:
    {
      int klass_reg;

      D.47449 = alloc_preg (cfg);
      klass_reg = (int) D.47449;
      {
        struct MonoInst * inst;

        D.47406 = cfg->mempool;
        inst = mono_mempool_alloc (D.47406, 80);
        inst->data.op[1].const_val = 0;
        D.47450 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.47450;
        inst->prev = 0B;
        D.47451 = inst->prev;
        inst->next = D.47451;
        D.47445 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.47446 = D.47445 & 33554432;
        if (D.47446 != 0) goto <D.47453>; else goto <D.47454>;
        <D.47453>:
        iftmp.421 = 732;
        goto <D.47455>;
        <D.47454>:
        iftmp.421 = 363;
        <D.47455>:
        inst->opcode = iftmp.421;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.47456 = inst->sreg3;
        inst->sreg2 = D.47456;
        D.47457 = inst->sreg2;
        inst->sreg1 = D.47457;
        D.47411 = cfg->ip;
        inst->cil_code = D.47411;
        inst->dreg = klass_reg;
        inst->data.op[0].p = array_class;
        inst->data.op[1].const_val = 11;
        D.47412 = cfg->cbb;
        D.47413 = D.47412->last_ins;
        if (D.47413 != 0B) goto <D.47458>; else goto <D.47459>;
        <D.47458>:
        D.47412 = cfg->cbb;
        D.47413 = D.47412->last_ins;
        D.47413->next = inst;
        D.47412 = cfg->cbb;
        D.47413 = D.47412->last_ins;
        inst->prev = D.47413;
        D.47412 = cfg->cbb;
        D.47412->last_ins = inst;
        goto <D.47460>;
        <D.47459>:
        D.47412 = cfg->cbb;
        D.47412 = cfg->cbb;
        D.47412->last_ins = inst;
        D.47413 = D.47412->last_ins;
        D.47412->code = D.47413;
        <D.47460>:
      }
      {
        struct MonoInst * inst;

        D.47406 = cfg->mempool;
        inst = mono_mempool_alloc (D.47406, 80);
        inst->data.op[1].const_val = 0;
        D.47461 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.47461;
        inst->prev = 0B;
        D.47462 = inst->prev;
        inst->next = D.47462;
        inst->opcode = 322;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.47463 = inst->sreg3;
        inst->sreg2 = D.47463;
        D.47464 = inst->sreg2;
        inst->sreg1 = D.47464;
        D.47411 = cfg->ip;
        inst->cil_code = D.47411;
        inst->dreg = -1;
        inst->sreg1 = class_reg;
        inst->sreg2 = klass_reg;
        D.47412 = cfg->cbb;
        D.47413 = D.47412->last_ins;
        if (D.47413 != 0B) goto <D.47465>; else goto <D.47466>;
        <D.47465>:
        D.47412 = cfg->cbb;
        D.47413 = D.47412->last_ins;
        D.47413->next = inst;
        D.47412 = cfg->cbb;
        D.47413 = D.47412->last_ins;
        inst->prev = D.47413;
        D.47412 = cfg->cbb;
        D.47412->last_ins = inst;
        goto <D.47467>;
        <D.47466>:
        D.47412 = cfg->cbb;
        D.47412 = cfg->cbb;
        D.47412->last_ins = inst;
        D.47413 = D.47412->last_ins;
        D.47412->code = D.47413;
        <D.47467>:
      }
    }
    goto <D.47468>;
    <D.47448>:
    {
      struct MonoInst * inst;

      D.47406 = cfg->mempool;
      inst = mono_mempool_alloc (D.47406, 80);
      inst->data.op[1].const_val = 0;
      D.47469 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47469;
      inst->prev = 0B;
      D.47470 = inst->prev;
      inst->next = D.47470;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47471 = inst->sreg3;
      inst->sreg2 = D.47471;
      D.47472 = inst->sreg2;
      inst->sreg1 = D.47472;
      D.47411 = cfg->ip;
      inst->cil_code = D.47411;
      inst->dreg = -1;
      inst->sreg1 = class_reg;
      array_class.422 = (long int) array_class;
      inst->data.op[1].const_val = array_class.422;
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      if (D.47413 != 0B) goto <D.47474>; else goto <D.47475>;
      <D.47474>:
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      D.47413->next = inst;
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      inst->prev = D.47413;
      D.47412 = cfg->cbb;
      D.47412->last_ins = inst;
      goto <D.47476>;
      <D.47475>:
      D.47412 = cfg->cbb;
      D.47412 = cfg->cbb;
      D.47412->last_ins = inst;
      D.47413 = D.47412->last_ins;
      D.47412->code = D.47413;
      <D.47476>:
    }
    <D.47468>:
  }
  goto <D.47477>;
  <D.47436>:
  if (context_used != 0) goto <D.47478>; else goto <D.47479>;
  <D.47478>:
  {
    struct MonoInst * vtable_ins;

    vtable_ins = emit_get_rgctx_klass (cfg, context_used, array_class, 2);
    {
      struct MonoInst * inst;

      D.47406 = cfg->mempool;
      inst = mono_mempool_alloc (D.47406, 80);
      inst->data.op[1].const_val = 0;
      D.47480 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47480;
      inst->prev = 0B;
      D.47481 = inst->prev;
      inst->next = D.47481;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47482 = inst->sreg3;
      inst->sreg2 = D.47482;
      D.47483 = inst->sreg2;
      inst->sreg1 = D.47483;
      D.47411 = cfg->ip;
      inst->cil_code = D.47411;
      inst->dreg = -1;
      inst->sreg1 = vtable_reg;
      D.47484 = vtable_ins->dreg;
      inst->sreg2 = D.47484;
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      if (D.47413 != 0B) goto <D.47485>; else goto <D.47486>;
      <D.47485>:
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      D.47413->next = inst;
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      inst->prev = D.47413;
      D.47412 = cfg->cbb;
      D.47412->last_ins = inst;
      goto <D.47487>;
      <D.47486>:
      D.47412 = cfg->cbb;
      D.47412 = cfg->cbb;
      D.47412->last_ins = inst;
      D.47413 = D.47412->last_ins;
      D.47412->code = D.47413;
      <D.47487>:
    }
  }
  goto <D.47488>;
  <D.47479>:
  D.47445 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.47446 = D.47445 & 33554432;
  if (D.47446 != 0) goto <D.47489>; else goto <D.47490>;
  <D.47489>:
  {
    int vt_reg;
    struct MonoVTable * vtable;

    D.47491 = cfg->domain;
    vtable = mono_class_vtable (D.47491, array_class);
    if (vtable == 0B) goto <D.47492>; else goto <D.47493>;
    <D.47492>:
    return;
    <D.47493>:
    D.47494 = alloc_preg (cfg);
    vt_reg = (int) D.47494;
    {
      struct MonoInst * inst;

      D.47406 = cfg->mempool;
      inst = mono_mempool_alloc (D.47406, 80);
      inst->data.op[1].const_val = 0;
      D.47495 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47495;
      inst->prev = 0B;
      D.47496 = inst->prev;
      inst->next = D.47496;
      D.47445 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.47446 = D.47445 & 33554432;
      if (D.47446 != 0) goto <D.47498>; else goto <D.47499>;
      <D.47498>:
      iftmp.423 = 732;
      goto <D.47500>;
      <D.47499>:
      iftmp.423 = 363;
      <D.47500>:
      inst->opcode = iftmp.423;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47501 = inst->sreg3;
      inst->sreg2 = D.47501;
      D.47502 = inst->sreg2;
      inst->sreg1 = D.47502;
      D.47411 = cfg->ip;
      inst->cil_code = D.47411;
      inst->dreg = vt_reg;
      D.47445 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.47446 = D.47445 & 33554432;
      if (D.47446 != 0) goto <D.47504>; else goto <D.47505>;
      <D.47504>:
      iftmp.424 = vtable->klass;
      goto <D.47506>;
      <D.47505>:
      iftmp.424 = vtable;
      <D.47506>:
      inst->data.op[0].p = iftmp.424;
      inst->data.op[1].const_val = 14;
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      if (D.47413 != 0B) goto <D.47507>; else goto <D.47508>;
      <D.47507>:
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      D.47413->next = inst;
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      inst->prev = D.47413;
      D.47412 = cfg->cbb;
      D.47412->last_ins = inst;
      goto <D.47509>;
      <D.47508>:
      D.47412 = cfg->cbb;
      D.47412 = cfg->cbb;
      D.47412->last_ins = inst;
      D.47413 = D.47412->last_ins;
      D.47412->code = D.47413;
      <D.47509>:
    }
    {
      struct MonoInst * inst;

      D.47406 = cfg->mempool;
      inst = mono_mempool_alloc (D.47406, 80);
      inst->data.op[1].const_val = 0;
      D.47510 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47510;
      inst->prev = 0B;
      D.47511 = inst->prev;
      inst->next = D.47511;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47512 = inst->sreg3;
      inst->sreg2 = D.47512;
      D.47513 = inst->sreg2;
      inst->sreg1 = D.47513;
      D.47411 = cfg->ip;
      inst->cil_code = D.47411;
      inst->dreg = -1;
      inst->sreg1 = vtable_reg;
      inst->sreg2 = vt_reg;
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      if (D.47413 != 0B) goto <D.47514>; else goto <D.47515>;
      <D.47514>:
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      D.47413->next = inst;
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      inst->prev = D.47413;
      D.47412 = cfg->cbb;
      D.47412->last_ins = inst;
      goto <D.47516>;
      <D.47515>:
      D.47412 = cfg->cbb;
      D.47412 = cfg->cbb;
      D.47412->last_ins = inst;
      D.47413 = D.47412->last_ins;
      D.47412->code = D.47413;
      <D.47516>:
    }
  }
  goto <D.47517>;
  <D.47490>:
  {
    struct MonoVTable * vtable;

    D.47491 = cfg->domain;
    vtable = mono_class_vtable (D.47491, array_class);
    if (vtable == 0B) goto <D.47518>; else goto <D.47519>;
    <D.47518>:
    return;
    <D.47519>:
    {
      struct MonoInst * inst;

      D.47406 = cfg->mempool;
      inst = mono_mempool_alloc (D.47406, 80);
      inst->data.op[1].const_val = 0;
      D.47520 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47520;
      inst->prev = 0B;
      D.47521 = inst->prev;
      inst->next = D.47521;
      inst->opcode = 323;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47522 = inst->sreg3;
      inst->sreg2 = D.47522;
      D.47523 = inst->sreg2;
      inst->sreg1 = D.47523;
      D.47411 = cfg->ip;
      inst->cil_code = D.47411;
      inst->dreg = -1;
      inst->sreg1 = vtable_reg;
      vtable.425 = (long int) vtable;
      inst->data.op[1].const_val = vtable.425;
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      if (D.47413 != 0B) goto <D.47525>; else goto <D.47526>;
      <D.47525>:
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      D.47413->next = inst;
      D.47412 = cfg->cbb;
      D.47413 = D.47412->last_ins;
      inst->prev = D.47413;
      D.47412 = cfg->cbb;
      D.47412->last_ins = inst;
      goto <D.47527>;
      <D.47526>:
      D.47412 = cfg->cbb;
      D.47412 = cfg->cbb;
      D.47412->last_ins = inst;
      D.47413 = D.47412->last_ins;
      D.47412->code = D.47413;
      <D.47527>:
    }
  }
  <D.47517>:
  <D.47488>:
  <D.47477>:
  {
    struct MonoInst * inst;

    D.47406 = cfg->mempool;
    inst = mono_mempool_alloc (D.47406, 80);
    inst->data.op[1].const_val = 0;
    D.47528 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47528;
    inst->prev = 0B;
    D.47529 = inst->prev;
    inst->next = D.47529;
    inst->opcode = 456;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47530 = inst->sreg3;
    inst->sreg2 = D.47530;
    D.47531 = inst->sreg2;
    inst->sreg1 = D.47531;
    D.47411 = cfg->ip;
    inst->cil_code = D.47411;
    inst->data.op[1].p = "ArrayTypeMismatchException";
    D.47412 = cfg->cbb;
    D.47413 = D.47412->last_ins;
    if (D.47413 != 0B) goto <D.47532>; else goto <D.47533>;
    <D.47532>:
    D.47412 = cfg->cbb;
    D.47413 = D.47412->last_ins;
    D.47413->next = inst;
    D.47412 = cfg->cbb;
    D.47413 = D.47412->last_ins;
    inst->prev = D.47413;
    D.47412 = cfg->cbb;
    D.47412->last_ins = inst;
    goto <D.47534>;
    <D.47533>:
    D.47412 = cfg->cbb;
    D.47412 = cfg->cbb;
    D.47412->last_ins = inst;
    D.47413 = D.47412->last_ins;
    D.47412->code = D.47413;
    <D.47534>:
  }
  reset_cast_details (cfg);
}


mini_emit_ldelema_1_ins (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * arr, struct MonoInst * index, gboolean bcheck)
{
  int D.47536;
  int D.47540;
  unsigned int D.47541;
  unsigned int D.47545;
  struct MonoMemPool * D.47546;
  long int D.47547;
  struct MonoInst * D.47548;
  int D.47549;
  int D.47550;
  const unsigned char * D.47551;
  struct MonoBasicBlock * D.47552;
  struct MonoInst * D.47553;
  unsigned int D.47559;
  unsigned int D.47560;
  unsigned int D.47563;
  long unsigned int D.47566;
  long unsigned int D.47567;
  long int D.47570;
  struct MonoInst * D.47571;
  int D.47572;
  int D.47573;
  long int D.47577;
  struct MonoInst * D.47578;
  int D.47579;
  int D.47580;
  unsigned int D.47587;
  int D.47590;
  long int D.47595;
  struct MonoInst * D.47596;
  int D.47597;
  int D.47598;
  long int D.47602;
  struct MonoInst * D.47603;
  int D.47604;
  int D.47605;
  long int D.47610;
  struct MonoInst * D.47611;
  int D.47612;
  int D.47613;
  unsigned char D.47614;
  int D.47619;
  long int D.47624;
  struct MonoInst * D.47625;
  int D.47626;
  int D.47627;
  long int D.47631;
  struct MonoInst * D.47632;
  int D.47633;
  int D.47634;
  long int D.47639;
  struct MonoInst * D.47640;
  int D.47641;
  int D.47642;
  unsigned char D.47643;
  long int D.47647;
  struct MonoInst * D.47648;
  int D.47649;
  int D.47650;
  long int D.47654;
  struct MonoInst * D.47655;
  int D.47656;
  int D.47657;
  unsigned int D.47662;
  int D.47665;
  long int D.47670;
  struct MonoInst * D.47671;
  int D.47672;
  int D.47673;
  long int D.47677;
  struct MonoInst * D.47678;
  int D.47679;
  int D.47680;
  long int D.47685;
  struct MonoInst * D.47686;
  int D.47687;
  int D.47688;
  unsigned char D.47689;
  int D.47694;
  long int D.47699;
  struct MonoInst * D.47700;
  int D.47701;
  int D.47702;
  long int D.47706;
  struct MonoInst * D.47707;
  int D.47708;
  int D.47709;
  long int D.47714;
  struct MonoInst * D.47715;
  int D.47716;
  int D.47717;
  unsigned char D.47718;
  long int D.47722;
  struct MonoInst * D.47723;
  int D.47724;
  int D.47725;
  long int D.47729;
  struct MonoInst * D.47730;
  int D.47731;
  int D.47732;
  long int D.47737;
  struct MonoInst * D.47738;
  int D.47739;
  int D.47740;
  unsigned char D.47741;
  unsigned char D.47742;
  unsigned int D.47746;
  unsigned int D.47747;
  unsigned int D.47748;
  struct MonoGenericSharingContext * D.47751;
  _Bool D.47752;
  long int D.47753;
  long int D.47754;
  _Bool D.47757;
  long int D.47758;
  long int D.47759;
  struct MonoType * D.47762;
  long int D.47763;
  struct MonoInst * D.47764;
  int D.47765;
  int D.47766;
  int D.47767;
  long int D.47772;
  struct MonoInst * D.47773;
  int D.47774;
  int D.47775;
  long int D.47776;
  long int D.47780;
  struct MonoInst * D.47781;
  int D.47782;
  int D.47783;
  long int D.47787;
  struct MonoInst * D.47788;
  int D.47789;
  int D.47790;
  struct MonoClass * D.47791;
  struct MonoInst * D.47795;
  struct MonoInst * ins;
  guint32 size;
  int mult_reg;
  int add_reg;
  int array_reg;
  int index_reg;
  int index2_reg;
  int context_used;

  D.47536 = mini_is_gsharedvt_variable_klass (cfg, klass);
  if (D.47536 != 0) goto <D.47537>; else goto <D.47538>;
  <D.47537>:
  size = 4294967295;
  goto <D.47539>;
  <D.47538>:
  mono_class_init (klass);
  D.47540 = mono_class_array_element_size (klass);
  size = (guint32) D.47540;
  <D.47539>:
  D.47541 = alloc_preg (cfg);
  mult_reg = (int) D.47541;
  array_reg = arr->dreg;
  index_reg = index->dreg;
  if (0 != 0) goto <D.47542>; else goto <D.47543>;
  <D.47542>:
  index2_reg = index_reg;
  goto <D.47544>;
  <D.47543>:
  D.47545 = alloc_preg (cfg);
  index2_reg = (int) D.47545;
  {
    struct MonoInst * inst;

    D.47546 = cfg->mempool;
    inst = mono_mempool_alloc (D.47546, 80);
    inst->data.op[1].const_val = 0;
    D.47547 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47547;
    inst->prev = 0B;
    D.47548 = inst->prev;
    inst->next = D.47548;
    inst->opcode = 762;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47549 = inst->sreg3;
    inst->sreg2 = D.47549;
    D.47550 = inst->sreg2;
    inst->sreg1 = D.47550;
    D.47551 = cfg->ip;
    inst->cil_code = D.47551;
    inst->dreg = index2_reg;
    inst->sreg1 = index_reg;
    D.47552 = cfg->cbb;
    D.47553 = D.47552->last_ins;
    if (D.47553 != 0B) goto <D.47554>; else goto <D.47555>;
    <D.47554>:
    D.47552 = cfg->cbb;
    D.47553 = D.47552->last_ins;
    D.47553->next = inst;
    D.47552 = cfg->cbb;
    D.47553 = D.47552->last_ins;
    inst->prev = D.47553;
    D.47552 = cfg->cbb;
    D.47552->last_ins = inst;
    goto <D.47556>;
    <D.47555>:
    D.47552 = cfg->cbb;
    D.47552 = cfg->cbb;
    D.47552->last_ins = inst;
    D.47553 = D.47552->last_ins;
    D.47552->code = D.47553;
    <D.47556>:
  }
  <D.47544>:
  if (bcheck != 0) goto <D.47557>; else goto <D.47558>;
  <D.47557>:
  D.47559 = cfg->opt;
  D.47560 = D.47559 & 134217728;
  if (D.47560 == 0) goto <D.47561>; else goto <D.47562>;
  <D.47561>:
  D.47559 = cfg->opt;
  D.47563 = D.47559 & 262144;
  if (D.47563 == 0) goto <D.47564>; else goto <D.47565>;
  <D.47564>:
  D.47566 = BIT_FIELD_REF <*cfg, 64, 5632>;
  D.47567 = D.47566 & 144115188075855872;
  if (D.47567 != 0) goto <D.47568>; else goto <D.47569>;
  <D.47568>:
  {
    struct MonoInst * inst;

    D.47546 = cfg->mempool;
    inst = mono_mempool_alloc (D.47546, 80);
    inst->data.op[1].const_val = 0;
    D.47570 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47570;
    inst->prev = 0B;
    D.47571 = inst->prev;
    inst->next = D.47571;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47572 = inst->sreg3;
    inst->sreg2 = D.47572;
    D.47573 = inst->sreg2;
    inst->sreg1 = D.47573;
    D.47551 = cfg->ip;
    inst->cil_code = D.47551;
    inst->dreg = -1;
    inst->sreg1 = array_reg;
    inst->data.op[1].const_val = 0;
    D.47552 = cfg->cbb;
    D.47553 = D.47552->last_ins;
    if (D.47553 != 0B) goto <D.47574>; else goto <D.47575>;
    <D.47574>:
    D.47552 = cfg->cbb;
    D.47553 = D.47552->last_ins;
    D.47553->next = inst;
    D.47552 = cfg->cbb;
    D.47553 = D.47552->last_ins;
    inst->prev = D.47553;
    D.47552 = cfg->cbb;
    D.47552->last_ins = inst;
    goto <D.47576>;
    <D.47575>:
    D.47552 = cfg->cbb;
    D.47552 = cfg->cbb;
    D.47552->last_ins = inst;
    D.47553 = D.47552->last_ins;
    D.47552->code = D.47553;
    <D.47576>:
  }
  {
    struct MonoInst * inst;

    D.47546 = cfg->mempool;
    inst = mono_mempool_alloc (D.47546, 80);
    inst->data.op[1].const_val = 0;
    D.47577 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47577;
    inst->prev = 0B;
    D.47578 = inst->prev;
    inst->next = D.47578;
    inst->opcode = 451;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47579 = inst->sreg3;
    inst->sreg2 = D.47579;
    D.47580 = inst->sreg2;
    inst->sreg1 = D.47580;
    D.47551 = cfg->ip;
    inst->cil_code = D.47551;
    inst->data.op[1].p = "NullReferenceException";
    D.47552 = cfg->cbb;
    D.47553 = D.47552->last_ins;
    if (D.47553 != 0B) goto <D.47581>; else goto <D.47582>;
    <D.47581>:
    D.47552 = cfg->cbb;
    D.47553 = D.47552->last_ins;
    D.47553->next = inst;
    D.47552 = cfg->cbb;
    D.47553 = D.47552->last_ins;
    inst->prev = D.47553;
    D.47552 = cfg->cbb;
    D.47552->last_ins = inst;
    goto <D.47583>;
    <D.47582>:
    D.47552 = cfg->cbb;
    D.47552 = cfg->cbb;
    D.47552->last_ins = inst;
    D.47553 = D.47552->last_ins;
    D.47552->code = D.47553;
    <D.47583>:
  }
  goto <D.47584>;
  <D.47569>:
  <D.47584>:
  if (0 != 0) goto <D.47585>; else goto <D.47586>;
  <D.47585>:
  {
    int _length_reg;

    D.47587 = alloc_ireg (cfg);
    _length_reg = (int) D.47587;
    if (1 != 0) goto <D.47588>; else goto <D.47589>;
    <D.47588>:
    {
      struct MonoInst * inst;
      int __ins_flags;

      __ins_flags = 32;
      D.47590 = __ins_flags & 32;
      if (D.47590 != 0) goto <D.47591>; else goto <D.47592>;
      <D.47591>:
      D.47566 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.47567 = D.47566 & 144115188075855872;
      if (D.47567 != 0) goto <D.47593>; else goto <D.47594>;
      <D.47593>:
      {
        struct MonoInst * inst;

        D.47546 = cfg->mempool;
        inst = mono_mempool_alloc (D.47546, 80);
        inst->data.op[1].const_val = 0;
        D.47595 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.47595;
        inst->prev = 0B;
        D.47596 = inst->prev;
        inst->next = D.47596;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.47597 = inst->sreg3;
        inst->sreg2 = D.47597;
        D.47598 = inst->sreg2;
        inst->sreg1 = D.47598;
        D.47551 = cfg->ip;
        inst->cil_code = D.47551;
        inst->dreg = -1;
        inst->sreg1 = array_reg;
        inst->data.op[1].const_val = 0;
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        if (D.47553 != 0B) goto <D.47599>; else goto <D.47600>;
        <D.47599>:
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        D.47553->next = inst;
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        inst->prev = D.47553;
        D.47552 = cfg->cbb;
        D.47552->last_ins = inst;
        goto <D.47601>;
        <D.47600>:
        D.47552 = cfg->cbb;
        D.47552 = cfg->cbb;
        D.47552->last_ins = inst;
        D.47553 = D.47552->last_ins;
        D.47552->code = D.47553;
        <D.47601>:
      }
      {
        struct MonoInst * inst;

        D.47546 = cfg->mempool;
        inst = mono_mempool_alloc (D.47546, 80);
        inst->data.op[1].const_val = 0;
        D.47602 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.47602;
        inst->prev = 0B;
        D.47603 = inst->prev;
        inst->next = D.47603;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.47604 = inst->sreg3;
        inst->sreg2 = D.47604;
        D.47605 = inst->sreg2;
        inst->sreg1 = D.47605;
        D.47551 = cfg->ip;
        inst->cil_code = D.47551;
        inst->data.op[1].p = "NullReferenceException";
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        if (D.47553 != 0B) goto <D.47606>; else goto <D.47607>;
        <D.47606>:
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        D.47553->next = inst;
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        inst->prev = D.47553;
        D.47552 = cfg->cbb;
        D.47552->last_ins = inst;
        goto <D.47608>;
        <D.47607>:
        D.47552 = cfg->cbb;
        D.47552 = cfg->cbb;
        D.47552->last_ins = inst;
        D.47553 = D.47552->last_ins;
        D.47552->code = D.47553;
        <D.47608>:
      }
      goto <D.47609>;
      <D.47594>:
      <D.47609>:
      <D.47592>:
      D.47546 = cfg->mempool;
      inst = mono_mempool_alloc (D.47546, 80);
      inst->data.op[1].const_val = 0;
      D.47610 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47610;
      inst->prev = 0B;
      D.47611 = inst->prev;
      inst->next = D.47611;
      inst->opcode = 393;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47612 = inst->sreg3;
      inst->sreg2 = D.47612;
      D.47613 = inst->sreg2;
      inst->sreg1 = D.47613;
      D.47551 = cfg->ip;
      inst->cil_code = D.47551;
      inst->dreg = _length_reg;
      inst->sreg1 = array_reg;
      inst->data.op[0].const_val = 24;
      inst->type = 1;
      D.47614 = (unsigned char) __ins_flags;
      inst->flags = D.47614;
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      if (D.47553 != 0B) goto <D.47615>; else goto <D.47616>;
      <D.47615>:
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      D.47553->next = inst;
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      inst->prev = D.47553;
      D.47552 = cfg->cbb;
      D.47552->last_ins = inst;
      goto <D.47617>;
      <D.47616>:
      D.47552 = cfg->cbb;
      D.47552 = cfg->cbb;
      D.47552->last_ins = inst;
      D.47553 = D.47552->last_ins;
      D.47552->code = D.47553;
      <D.47617>:
    }
    goto <D.47618>;
    <D.47589>:
    {
      struct MonoInst * inst;
      int __ins_flags;

      __ins_flags = 64;
      D.47619 = __ins_flags & 32;
      if (D.47619 != 0) goto <D.47620>; else goto <D.47621>;
      <D.47620>:
      D.47566 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.47567 = D.47566 & 144115188075855872;
      if (D.47567 != 0) goto <D.47622>; else goto <D.47623>;
      <D.47622>:
      {
        struct MonoInst * inst;

        D.47546 = cfg->mempool;
        inst = mono_mempool_alloc (D.47546, 80);
        inst->data.op[1].const_val = 0;
        D.47624 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.47624;
        inst->prev = 0B;
        D.47625 = inst->prev;
        inst->next = D.47625;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.47626 = inst->sreg3;
        inst->sreg2 = D.47626;
        D.47627 = inst->sreg2;
        inst->sreg1 = D.47627;
        D.47551 = cfg->ip;
        inst->cil_code = D.47551;
        inst->dreg = -1;
        inst->sreg1 = array_reg;
        inst->data.op[1].const_val = 0;
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        if (D.47553 != 0B) goto <D.47628>; else goto <D.47629>;
        <D.47628>:
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        D.47553->next = inst;
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        inst->prev = D.47553;
        D.47552 = cfg->cbb;
        D.47552->last_ins = inst;
        goto <D.47630>;
        <D.47629>:
        D.47552 = cfg->cbb;
        D.47552 = cfg->cbb;
        D.47552->last_ins = inst;
        D.47553 = D.47552->last_ins;
        D.47552->code = D.47553;
        <D.47630>:
      }
      {
        struct MonoInst * inst;

        D.47546 = cfg->mempool;
        inst = mono_mempool_alloc (D.47546, 80);
        inst->data.op[1].const_val = 0;
        D.47631 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.47631;
        inst->prev = 0B;
        D.47632 = inst->prev;
        inst->next = D.47632;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.47633 = inst->sreg3;
        inst->sreg2 = D.47633;
        D.47634 = inst->sreg2;
        inst->sreg1 = D.47634;
        D.47551 = cfg->ip;
        inst->cil_code = D.47551;
        inst->data.op[1].p = "NullReferenceException";
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        if (D.47553 != 0B) goto <D.47635>; else goto <D.47636>;
        <D.47635>:
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        D.47553->next = inst;
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        inst->prev = D.47553;
        D.47552 = cfg->cbb;
        D.47552->last_ins = inst;
        goto <D.47637>;
        <D.47636>:
        D.47552 = cfg->cbb;
        D.47552 = cfg->cbb;
        D.47552->last_ins = inst;
        D.47553 = D.47552->last_ins;
        D.47552->code = D.47553;
        <D.47637>:
      }
      goto <D.47638>;
      <D.47623>:
      <D.47638>:
      <D.47621>:
      D.47546 = cfg->mempool;
      inst = mono_mempool_alloc (D.47546, 80);
      inst->data.op[1].const_val = 0;
      D.47639 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47639;
      inst->prev = 0B;
      D.47640 = inst->prev;
      inst->next = D.47640;
      inst->opcode = 393;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47641 = inst->sreg3;
      inst->sreg2 = D.47641;
      D.47642 = inst->sreg2;
      inst->sreg1 = D.47642;
      D.47551 = cfg->ip;
      inst->cil_code = D.47551;
      inst->dreg = _length_reg;
      inst->sreg1 = array_reg;
      inst->data.op[0].const_val = 24;
      inst->type = 1;
      D.47643 = (unsigned char) __ins_flags;
      inst->flags = D.47643;
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      if (D.47553 != 0B) goto <D.47644>; else goto <D.47645>;
      <D.47644>:
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      D.47553->next = inst;
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      inst->prev = D.47553;
      D.47552 = cfg->cbb;
      D.47552->last_ins = inst;
      goto <D.47646>;
      <D.47645>:
      D.47552 = cfg->cbb;
      D.47552 = cfg->cbb;
      D.47552->last_ins = inst;
      D.47553 = D.47552->last_ins;
      D.47552->code = D.47553;
      <D.47646>:
    }
    <D.47618>:
    {
      struct MonoInst * inst;

      D.47546 = cfg->mempool;
      inst = mono_mempool_alloc (D.47546, 80);
      inst->data.op[1].const_val = 0;
      D.47647 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47647;
      inst->prev = 0B;
      D.47648 = inst->prev;
      inst->next = D.47648;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47649 = inst->sreg3;
      inst->sreg2 = D.47649;
      D.47650 = inst->sreg2;
      inst->sreg1 = D.47650;
      D.47551 = cfg->ip;
      inst->cil_code = D.47551;
      inst->dreg = -1;
      inst->sreg1 = _length_reg;
      inst->sreg2 = index2_reg;
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      if (D.47553 != 0B) goto <D.47651>; else goto <D.47652>;
      <D.47651>:
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      D.47553->next = inst;
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      inst->prev = D.47553;
      D.47552 = cfg->cbb;
      D.47552->last_ins = inst;
      goto <D.47653>;
      <D.47652>:
      D.47552 = cfg->cbb;
      D.47552 = cfg->cbb;
      D.47552->last_ins = inst;
      D.47553 = D.47552->last_ins;
      D.47552->code = D.47553;
      <D.47653>:
    }
    {
      struct MonoInst * inst;

      D.47546 = cfg->mempool;
      inst = mono_mempool_alloc (D.47546, 80);
      inst->data.op[1].const_val = 0;
      D.47654 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47654;
      inst->prev = 0B;
      D.47655 = inst->prev;
      inst->next = D.47655;
      inst->opcode = 459;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47656 = inst->sreg3;
      inst->sreg2 = D.47656;
      D.47657 = inst->sreg2;
      inst->sreg1 = D.47657;
      D.47551 = cfg->ip;
      inst->cil_code = D.47551;
      inst->data.op[1].p = "IndexOutOfRangeException";
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      if (D.47553 != 0B) goto <D.47658>; else goto <D.47659>;
      <D.47658>:
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      D.47553->next = inst;
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      inst->prev = D.47553;
      D.47552 = cfg->cbb;
      D.47552->last_ins = inst;
      goto <D.47660>;
      <D.47659>:
      D.47552 = cfg->cbb;
      D.47552 = cfg->cbb;
      D.47552->last_ins = inst;
      D.47553 = D.47552->last_ins;
      D.47552->code = D.47553;
      <D.47660>:
    }
  }
  goto <D.47661>;
  <D.47586>:
  {
    int _length_reg;

    D.47662 = alloc_ireg (cfg);
    _length_reg = (int) D.47662;
    if (1 != 0) goto <D.47663>; else goto <D.47664>;
    <D.47663>:
    {
      struct MonoInst * inst;
      int __ins_flags;

      __ins_flags = 32;
      D.47665 = __ins_flags & 32;
      if (D.47665 != 0) goto <D.47666>; else goto <D.47667>;
      <D.47666>:
      D.47566 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.47567 = D.47566 & 144115188075855872;
      if (D.47567 != 0) goto <D.47668>; else goto <D.47669>;
      <D.47668>:
      {
        struct MonoInst * inst;

        D.47546 = cfg->mempool;
        inst = mono_mempool_alloc (D.47546, 80);
        inst->data.op[1].const_val = 0;
        D.47670 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.47670;
        inst->prev = 0B;
        D.47671 = inst->prev;
        inst->next = D.47671;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.47672 = inst->sreg3;
        inst->sreg2 = D.47672;
        D.47673 = inst->sreg2;
        inst->sreg1 = D.47673;
        D.47551 = cfg->ip;
        inst->cil_code = D.47551;
        inst->dreg = -1;
        inst->sreg1 = array_reg;
        inst->data.op[1].const_val = 0;
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        if (D.47553 != 0B) goto <D.47674>; else goto <D.47675>;
        <D.47674>:
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        D.47553->next = inst;
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        inst->prev = D.47553;
        D.47552 = cfg->cbb;
        D.47552->last_ins = inst;
        goto <D.47676>;
        <D.47675>:
        D.47552 = cfg->cbb;
        D.47552 = cfg->cbb;
        D.47552->last_ins = inst;
        D.47553 = D.47552->last_ins;
        D.47552->code = D.47553;
        <D.47676>:
      }
      {
        struct MonoInst * inst;

        D.47546 = cfg->mempool;
        inst = mono_mempool_alloc (D.47546, 80);
        inst->data.op[1].const_val = 0;
        D.47677 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.47677;
        inst->prev = 0B;
        D.47678 = inst->prev;
        inst->next = D.47678;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.47679 = inst->sreg3;
        inst->sreg2 = D.47679;
        D.47680 = inst->sreg2;
        inst->sreg1 = D.47680;
        D.47551 = cfg->ip;
        inst->cil_code = D.47551;
        inst->data.op[1].p = "NullReferenceException";
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        if (D.47553 != 0B) goto <D.47681>; else goto <D.47682>;
        <D.47681>:
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        D.47553->next = inst;
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        inst->prev = D.47553;
        D.47552 = cfg->cbb;
        D.47552->last_ins = inst;
        goto <D.47683>;
        <D.47682>:
        D.47552 = cfg->cbb;
        D.47552 = cfg->cbb;
        D.47552->last_ins = inst;
        D.47553 = D.47552->last_ins;
        D.47552->code = D.47553;
        <D.47683>:
      }
      goto <D.47684>;
      <D.47669>:
      <D.47684>:
      <D.47667>:
      D.47546 = cfg->mempool;
      inst = mono_mempool_alloc (D.47546, 80);
      inst->data.op[1].const_val = 0;
      D.47685 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47685;
      inst->prev = 0B;
      D.47686 = inst->prev;
      inst->next = D.47686;
      inst->opcode = 393;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47687 = inst->sreg3;
      inst->sreg2 = D.47687;
      D.47688 = inst->sreg2;
      inst->sreg1 = D.47688;
      D.47551 = cfg->ip;
      inst->cil_code = D.47551;
      inst->dreg = _length_reg;
      inst->sreg1 = array_reg;
      inst->data.op[0].const_val = 24;
      inst->type = 1;
      D.47689 = (unsigned char) __ins_flags;
      inst->flags = D.47689;
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      if (D.47553 != 0B) goto <D.47690>; else goto <D.47691>;
      <D.47690>:
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      D.47553->next = inst;
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      inst->prev = D.47553;
      D.47552 = cfg->cbb;
      D.47552->last_ins = inst;
      goto <D.47692>;
      <D.47691>:
      D.47552 = cfg->cbb;
      D.47552 = cfg->cbb;
      D.47552->last_ins = inst;
      D.47553 = D.47552->last_ins;
      D.47552->code = D.47553;
      <D.47692>:
    }
    goto <D.47693>;
    <D.47664>:
    {
      struct MonoInst * inst;
      int __ins_flags;

      __ins_flags = 64;
      D.47694 = __ins_flags & 32;
      if (D.47694 != 0) goto <D.47695>; else goto <D.47696>;
      <D.47695>:
      D.47566 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.47567 = D.47566 & 144115188075855872;
      if (D.47567 != 0) goto <D.47697>; else goto <D.47698>;
      <D.47697>:
      {
        struct MonoInst * inst;

        D.47546 = cfg->mempool;
        inst = mono_mempool_alloc (D.47546, 80);
        inst->data.op[1].const_val = 0;
        D.47699 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.47699;
        inst->prev = 0B;
        D.47700 = inst->prev;
        inst->next = D.47700;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.47701 = inst->sreg3;
        inst->sreg2 = D.47701;
        D.47702 = inst->sreg2;
        inst->sreg1 = D.47702;
        D.47551 = cfg->ip;
        inst->cil_code = D.47551;
        inst->dreg = -1;
        inst->sreg1 = array_reg;
        inst->data.op[1].const_val = 0;
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        if (D.47553 != 0B) goto <D.47703>; else goto <D.47704>;
        <D.47703>:
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        D.47553->next = inst;
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        inst->prev = D.47553;
        D.47552 = cfg->cbb;
        D.47552->last_ins = inst;
        goto <D.47705>;
        <D.47704>:
        D.47552 = cfg->cbb;
        D.47552 = cfg->cbb;
        D.47552->last_ins = inst;
        D.47553 = D.47552->last_ins;
        D.47552->code = D.47553;
        <D.47705>:
      }
      {
        struct MonoInst * inst;

        D.47546 = cfg->mempool;
        inst = mono_mempool_alloc (D.47546, 80);
        inst->data.op[1].const_val = 0;
        D.47706 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.47706;
        inst->prev = 0B;
        D.47707 = inst->prev;
        inst->next = D.47707;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.47708 = inst->sreg3;
        inst->sreg2 = D.47708;
        D.47709 = inst->sreg2;
        inst->sreg1 = D.47709;
        D.47551 = cfg->ip;
        inst->cil_code = D.47551;
        inst->data.op[1].p = "NullReferenceException";
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        if (D.47553 != 0B) goto <D.47710>; else goto <D.47711>;
        <D.47710>:
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        D.47553->next = inst;
        D.47552 = cfg->cbb;
        D.47553 = D.47552->last_ins;
        inst->prev = D.47553;
        D.47552 = cfg->cbb;
        D.47552->last_ins = inst;
        goto <D.47712>;
        <D.47711>:
        D.47552 = cfg->cbb;
        D.47552 = cfg->cbb;
        D.47552->last_ins = inst;
        D.47553 = D.47552->last_ins;
        D.47552->code = D.47553;
        <D.47712>:
      }
      goto <D.47713>;
      <D.47698>:
      <D.47713>:
      <D.47696>:
      D.47546 = cfg->mempool;
      inst = mono_mempool_alloc (D.47546, 80);
      inst->data.op[1].const_val = 0;
      D.47714 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47714;
      inst->prev = 0B;
      D.47715 = inst->prev;
      inst->next = D.47715;
      inst->opcode = 393;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47716 = inst->sreg3;
      inst->sreg2 = D.47716;
      D.47717 = inst->sreg2;
      inst->sreg1 = D.47717;
      D.47551 = cfg->ip;
      inst->cil_code = D.47551;
      inst->dreg = _length_reg;
      inst->sreg1 = array_reg;
      inst->data.op[0].const_val = 24;
      inst->type = 1;
      D.47718 = (unsigned char) __ins_flags;
      inst->flags = D.47718;
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      if (D.47553 != 0B) goto <D.47719>; else goto <D.47720>;
      <D.47719>:
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      D.47553->next = inst;
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      inst->prev = D.47553;
      D.47552 = cfg->cbb;
      D.47552->last_ins = inst;
      goto <D.47721>;
      <D.47720>:
      D.47552 = cfg->cbb;
      D.47552 = cfg->cbb;
      D.47552->last_ins = inst;
      D.47553 = D.47552->last_ins;
      D.47552->code = D.47553;
      <D.47721>:
    }
    <D.47693>:
    {
      struct MonoInst * inst;

      D.47546 = cfg->mempool;
      inst = mono_mempool_alloc (D.47546, 80);
      inst->data.op[1].const_val = 0;
      D.47722 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47722;
      inst->prev = 0B;
      D.47723 = inst->prev;
      inst->next = D.47723;
      inst->opcode = 322;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47724 = inst->sreg3;
      inst->sreg2 = D.47724;
      D.47725 = inst->sreg2;
      inst->sreg1 = D.47725;
      D.47551 = cfg->ip;
      inst->cil_code = D.47551;
      inst->dreg = -1;
      inst->sreg1 = _length_reg;
      inst->sreg2 = index2_reg;
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      if (D.47553 != 0B) goto <D.47726>; else goto <D.47727>;
      <D.47726>:
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      D.47553->next = inst;
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      inst->prev = D.47553;
      D.47552 = cfg->cbb;
      D.47552->last_ins = inst;
      goto <D.47728>;
      <D.47727>:
      D.47552 = cfg->cbb;
      D.47552 = cfg->cbb;
      D.47552->last_ins = inst;
      D.47553 = D.47552->last_ins;
      D.47552->code = D.47553;
      <D.47728>:
    }
    {
      struct MonoInst * inst;

      D.47546 = cfg->mempool;
      inst = mono_mempool_alloc (D.47546, 80);
      inst->data.op[1].const_val = 0;
      D.47729 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47729;
      inst->prev = 0B;
      D.47730 = inst->prev;
      inst->next = D.47730;
      inst->opcode = 459;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47731 = inst->sreg3;
      inst->sreg2 = D.47731;
      D.47732 = inst->sreg2;
      inst->sreg1 = D.47732;
      D.47551 = cfg->ip;
      inst->cil_code = D.47551;
      inst->data.op[1].p = "IndexOutOfRangeException";
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      if (D.47553 != 0B) goto <D.47733>; else goto <D.47734>;
      <D.47733>:
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      D.47553->next = inst;
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      inst->prev = D.47553;
      D.47552 = cfg->cbb;
      D.47552->last_ins = inst;
      goto <D.47735>;
      <D.47734>:
      D.47552 = cfg->cbb;
      D.47552 = cfg->cbb;
      D.47552->last_ins = inst;
      D.47553 = D.47552->last_ins;
      D.47552->code = D.47553;
      <D.47735>:
    }
  }
  <D.47661>:
  goto <D.47736>;
  <D.47565>:
  {
    struct MonoInst * ins;

    D.47546 = cfg->mempool;
    ins = mono_mempool_alloc (D.47546, 80);
    ins->data.op[1].const_val = 0;
    D.47737 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.47737;
    ins->prev = 0B;
    D.47738 = ins->prev;
    ins->next = D.47738;
    ins->opcode = 784;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.47739 = ins->sreg3;
    ins->sreg2 = D.47739;
    D.47740 = ins->sreg2;
    ins->sreg1 = D.47740;
    D.47551 = cfg->ip;
    ins->cil_code = D.47551;
    ins->sreg1 = array_reg;
    ins->sreg2 = index2_reg;
    ins->data.op[1].const_val = 24;
    D.47741 = ins->flags;
    D.47742 = D.47741 | 32;
    ins->flags = D.47742;
    D.47552 = cfg->cbb;
    D.47553 = D.47552->last_ins;
    if (D.47553 != 0B) goto <D.47743>; else goto <D.47744>;
    <D.47743>:
    D.47552 = cfg->cbb;
    D.47553 = D.47552->last_ins;
    D.47553->next = ins;
    D.47552 = cfg->cbb;
    D.47553 = D.47552->last_ins;
    ins->prev = D.47553;
    D.47552 = cfg->cbb;
    D.47552->last_ins = ins;
    goto <D.47745>;
    <D.47744>:
    D.47552 = cfg->cbb;
    D.47552 = cfg->cbb;
    D.47552->last_ins = ins;
    D.47553 = D.47552->last_ins;
    D.47552->code = D.47553;
    <D.47745>:
    D.47746 = cfg->flags;
    D.47747 = D.47746 | 256;
    cfg->flags = D.47747;
    D.47552 = cfg->cbb;
    D.47552->has_array_access = 1;
  }
  <D.47736>:
  <D.47562>:
  <D.47558>:
  D.47748 = alloc_ireg_mp (cfg);
  add_reg = (int) D.47748;
  if (size == 4294967295) goto <D.47749>; else goto <D.47750>;
  <D.47749>:
  {
    struct MonoInst * rgctx_ins;

    D.47751 = cfg->generic_sharing_context;
    D.47752 = D.47751 == 0B;
    D.47753 = (long int) D.47752;
    D.47754 = __builtin_expect (D.47753, 0);
    if (D.47754 != 0) goto <D.47755>; else goto <D.47756>;
    <D.47755>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4718, "cfg->generic_sharing_context");
    <D.47756>:
    context_used = mini_class_check_context_used (cfg, klass);
    D.47757 = context_used == 0;
    D.47758 = (long int) D.47757;
    D.47759 = __builtin_expect (D.47758, 0);
    if (D.47759 != 0) goto <D.47760>; else goto <D.47761>;
    <D.47760>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4720, "context_used");
    <D.47761>:
    D.47762 = &klass->byval_arg;
    rgctx_ins = emit_get_gsharedvt_info (cfg, D.47762, 13);
    {
      struct MonoInst * inst;

      D.47546 = cfg->mempool;
      inst = mono_mempool_alloc (D.47546, 80);
      inst->data.op[1].const_val = 0;
      D.47763 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.47763;
      inst->prev = 0B;
      D.47764 = inst->prev;
      inst->next = D.47764;
      inst->opcode = 567;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.47765 = inst->sreg3;
      inst->sreg2 = D.47765;
      D.47766 = inst->sreg2;
      inst->sreg1 = D.47766;
      D.47551 = cfg->ip;
      inst->cil_code = D.47551;
      inst->dreg = mult_reg;
      inst->sreg1 = index2_reg;
      D.47767 = rgctx_ins->dreg;
      inst->sreg2 = D.47767;
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      if (D.47553 != 0B) goto <D.47768>; else goto <D.47769>;
      <D.47768>:
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      D.47553->next = inst;
      D.47552 = cfg->cbb;
      D.47553 = D.47552->last_ins;
      inst->prev = D.47553;
      D.47552 = cfg->cbb;
      D.47552->last_ins = inst;
      goto <D.47770>;
      <D.47769>:
      D.47552 = cfg->cbb;
      D.47552 = cfg->cbb;
      D.47552->last_ins = inst;
      D.47553 = D.47552->last_ins;
      D.47552->code = D.47553;
      <D.47770>:
    }
  }
  goto <D.47771>;
  <D.47750>:
  {
    struct MonoInst * inst;

    D.47546 = cfg->mempool;
    inst = mono_mempool_alloc (D.47546, 80);
    inst->data.op[1].const_val = 0;
    D.47772 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47772;
    inst->prev = 0B;
    D.47773 = inst->prev;
    inst->next = D.47773;
    inst->opcode = 431;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47774 = inst->sreg3;
    inst->sreg2 = D.47774;
    D.47775 = inst->sreg2;
    inst->sreg1 = D.47775;
    D.47551 = cfg->ip;
    inst->cil_code = D.47551;
    inst->dreg = mult_reg;
    inst->sreg1 = index2_reg;
    D.47776 = (long int) size;
    inst->data.op[1].const_val = D.47776;
    D.47552 = cfg->cbb;
    D.47553 = D.47552->last_ins;
    if (D.47553 != 0B) goto <D.47777>; else goto <D.47778>;
    <D.47777>:
    D.47552 = cfg->cbb;
    D.47553 = D.47552->last_ins;
    D.47553->next = inst;
    D.47552 = cfg->cbb;
    D.47553 = D.47552->last_ins;
    inst->prev = D.47553;
    D.47552 = cfg->cbb;
    D.47552->last_ins = inst;
    goto <D.47779>;
    <D.47778>:
    D.47552 = cfg->cbb;
    D.47552 = cfg->cbb;
    D.47552->last_ins = inst;
    D.47553 = D.47552->last_ins;
    D.47552->code = D.47553;
    <D.47779>:
  }
  <D.47771>:
  {
    struct MonoInst * inst;

    D.47546 = cfg->mempool;
    inst = mono_mempool_alloc (D.47546, 80);
    inst->data.op[1].const_val = 0;
    D.47780 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.47780;
    inst->prev = 0B;
    D.47781 = inst->prev;
    inst->next = D.47781;
    inst->opcode = 479;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.47782 = inst->sreg3;
    inst->sreg2 = D.47782;
    D.47783 = inst->sreg2;
    inst->sreg1 = D.47783;
    D.47551 = cfg->ip;
    inst->cil_code = D.47551;
    inst->dreg = add_reg;
    inst->sreg1 = array_reg;
    inst->sreg2 = mult_reg;
    D.47552 = cfg->cbb;
    D.47553 = D.47552->last_ins;
    if (D.47553 != 0B) goto <D.47784>; else goto <D.47785>;
    <D.47784>:
    D.47552 = cfg->cbb;
    D.47553 = D.47552->last_ins;
    D.47553->next = inst;
    D.47552 = cfg->cbb;
    D.47553 = D.47552->last_ins;
    inst->prev = D.47553;
    D.47552 = cfg->cbb;
    D.47552->last_ins = inst;
    goto <D.47786>;
    <D.47785>:
    D.47552 = cfg->cbb;
    D.47552 = cfg->cbb;
    D.47552->last_ins = inst;
    D.47553 = D.47552->last_ins;
    D.47552->code = D.47553;
    <D.47786>:
  }
  D.47546 = cfg->mempool;
  ins = mono_mempool_alloc (D.47546, 80);
  ins->data.op[1].const_val = 0;
  D.47787 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.47787;
  ins->prev = 0B;
  D.47788 = ins->prev;
  ins->next = D.47788;
  ins->opcode = 538;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.47789 = ins->sreg3;
  ins->sreg2 = D.47789;
  D.47790 = ins->sreg2;
  ins->sreg1 = D.47790;
  D.47551 = cfg->ip;
  ins->cil_code = D.47551;
  ins->dreg = add_reg;
  ins->sreg1 = add_reg;
  ins->data.op[1].const_val = 32;
  D.47791 = mono_class_get_element_class (klass);
  ins->klass = D.47791;
  ins->type = 5;
  D.47552 = cfg->cbb;
  D.47553 = D.47552->last_ins;
  if (D.47553 != 0B) goto <D.47792>; else goto <D.47793>;
  <D.47792>:
  D.47552 = cfg->cbb;
  D.47553 = D.47552->last_ins;
  D.47553->next = ins;
  D.47552 = cfg->cbb;
  D.47553 = D.47552->last_ins;
  ins->prev = D.47553;
  D.47552 = cfg->cbb;
  D.47552->last_ins = ins;
  goto <D.47794>;
  <D.47793>:
  D.47552 = cfg->cbb;
  D.47552 = cfg->cbb;
  D.47552->last_ins = ins;
  D.47553 = D.47552->last_ins;
  D.47552->code = D.47553;
  <D.47794>:
  D.47795 = ins;
  return D.47795;
}


array_access_to_klass (int opcode)
{
  struct MonoClass * D.47797;

  switch (opcode) <default: <D.25338>, case 144: <D.25323>, case 145: <D.25319>, case 146: <D.25325>, case 147: <D.25320>, case 148: <D.25327>, case 149: <D.25329>, case 150: <D.25330>, case 151: <D.25321>, case 152: <D.25332>, case 153: <D.25334>, case 154: <D.25336>, case 155: <D.25322>, case 156: <D.25324>, case 157: <D.25326>, case 158: <D.25328>, case 159: <D.25331>, case 160: <D.25333>, case 161: <D.25335>, case 162: <D.25337>>
  <D.25319>:
  D.47797 = mono_defaults.byte_class;
  return D.47797;
  <D.25320>:
  D.47797 = mono_defaults.uint16_class;
  return D.47797;
  <D.25321>:
  <D.25322>:
  D.47797 = mono_defaults.int_class;
  return D.47797;
  <D.25323>:
  <D.25324>:
  D.47797 = mono_defaults.sbyte_class;
  return D.47797;
  <D.25325>:
  <D.25326>:
  D.47797 = mono_defaults.int16_class;
  return D.47797;
  <D.25327>:
  <D.25328>:
  D.47797 = mono_defaults.int32_class;
  return D.47797;
  <D.25329>:
  D.47797 = mono_defaults.uint32_class;
  return D.47797;
  <D.25330>:
  <D.25331>:
  D.47797 = mono_defaults.int64_class;
  return D.47797;
  <D.25332>:
  <D.25333>:
  D.47797 = mono_defaults.single_class;
  return D.47797;
  <D.25334>:
  <D.25335>:
  D.47797 = mono_defaults.double_class;
  return D.47797;
  <D.25336>:
  <D.25337>:
  D.47797 = mono_defaults.object_class;
  return D.47797;
  <D.25338>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 1271);
  D.47797 = 0B;
  return D.47797;
}


emit_array_store (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * * sp, gboolean safety_checks)
{
  int D.47802;
  struct MonoInst * * D.47804;
  struct MonoInst * D.47805;
  short unsigned int D.47806;
  void * D.47808;
  struct MonoClass * obj_array.428;
  struct MonoClass * tmp_klass.426;
  struct MonoClass * D.47812;
  struct MonoClass * tmp_klass.427;
  _Bool D.47814;
  long int D.47815;
  long int D.47816;
  short int D.47819;
  _Bool D.47822;
  long int D.47823;
  long int D.47824;
  struct MonoInst * D.47827;
  unsigned char D.47828;
  struct MonoInst * D.47831;
  unsigned char D.47832;
  struct MonoInst * D.47835;
  struct MonoInst * D.47836;
  int D.47837;
  struct MonoInst * * D.47840;
  struct MonoInst * D.47841;
  struct MonoMemPool * D.47842;
  long int D.47843;
  struct MonoInst * D.47844;
  struct MonoType * D.47845;
  unsigned int D.47846;
  short unsigned int D.47847;
  int D.47848;
  int D.47849;
  const unsigned char * D.47850;
  int D.47851;
  int D.47852;
  struct MonoClass * D.47853;
  struct MonoBasicBlock * D.47854;
  struct MonoInst * D.47855;
  short unsigned int D.47860;
  int D.47863;
  unsigned int D.47864;
  long int D.47865;
  unsigned int D.47866;
  unsigned int D.47867;
  unsigned int D.47868;
  unsigned int D.47871;
  unsigned int D.47872;
  unsigned int D.47875;
  long unsigned int D.47878;
  long unsigned int D.47879;
  long int D.47882;
  struct MonoInst * D.47883;
  int D.47884;
  int D.47885;
  long int D.47889;
  struct MonoInst * D.47890;
  int D.47891;
  int D.47892;
  unsigned int D.47899;
  int D.47902;
  long int D.47907;
  struct MonoInst * D.47908;
  int D.47909;
  int D.47910;
  long int D.47914;
  struct MonoInst * D.47915;
  int D.47916;
  int D.47917;
  long int D.47922;
  struct MonoInst * D.47923;
  int D.47924;
  int D.47925;
  unsigned char D.47926;
  int D.47931;
  long int D.47936;
  struct MonoInst * D.47937;
  int D.47938;
  int D.47939;
  long int D.47943;
  struct MonoInst * D.47944;
  int D.47945;
  int D.47946;
  long int D.47951;
  struct MonoInst * D.47952;
  int D.47953;
  int D.47954;
  unsigned char D.47955;
  long int D.47959;
  struct MonoInst * D.47960;
  int D.47961;
  int D.47962;
  long int D.47966;
  struct MonoInst * D.47967;
  int D.47968;
  int D.47969;
  unsigned int D.47974;
  int D.47977;
  long int D.47982;
  struct MonoInst * D.47983;
  int D.47984;
  int D.47985;
  long int D.47989;
  struct MonoInst * D.47990;
  int D.47991;
  int D.47992;
  long int D.47997;
  struct MonoInst * D.47998;
  int D.47999;
  int D.48000;
  unsigned char D.48001;
  int D.48006;
  long int D.48011;
  struct MonoInst * D.48012;
  int D.48013;
  int D.48014;
  long int D.48018;
  struct MonoInst * D.48019;
  int D.48020;
  int D.48021;
  long int D.48026;
  struct MonoInst * D.48027;
  int D.48028;
  int D.48029;
  unsigned char D.48030;
  long int D.48034;
  struct MonoInst * D.48035;
  int D.48036;
  int D.48037;
  long int D.48041;
  struct MonoInst * D.48042;
  int D.48043;
  int D.48044;
  long int D.48049;
  struct MonoInst * D.48050;
  int D.48051;
  int D.48052;
  unsigned char D.48053;
  unsigned char D.48054;
  unsigned int D.48058;
  unsigned int D.48059;
  unsigned int D.48060;
  short unsigned int D.48061;
  long int D.48062;
  struct MonoClass * D.48063;
  unsigned int D.48068;
  short unsigned int D.48069;
  int D.48070;
  struct MonoClass * D.48071;
  int D.48075;

  if (safety_checks != 0) goto <D.47801>; else goto <D.47799>;
  <D.47801>:
  D.47802 = generic_class_is_reference_type (cfg, klass);
  if (D.47802 != 0) goto <D.47803>; else goto <D.47799>;
  <D.47803>:
  D.47804 = sp + 16;
  D.47805 = *D.47804;
  D.47806 = D.47805->opcode;
  if (D.47806 != 363) goto <D.47800>; else goto <D.47807>;
  <D.47807>:
  D.47804 = sp + 16;
  D.47805 = *D.47804;
  D.47808 = D.47805->data.op[0].p;
  if (D.47808 != 0B) goto <D.47800>; else goto <D.47799>;
  <D.47800>:
  {
    struct MonoClass * obj_array;
    struct MonoMethod * helper;
    struct MonoInst * iargs[3];

    try
      {
        {
          static struct MonoClass * tmp_klass;

          {
            tmp_klass.426 = tmp_klass;
            if (tmp_klass.426 == 0B) goto <D.47810>; else goto <D.47811>;
            <D.47810>:
            D.47812 = mono_defaults.object_class;
            tmp_klass.427 = mono_array_class_get (D.47812, 1);
            tmp_klass = tmp_klass.427;
            tmp_klass.426 = tmp_klass;
            D.47814 = tmp_klass.426 == 0B;
            D.47815 = (long int) D.47814;
            D.47816 = __builtin_expect (D.47815, 0);
            if (D.47816 != 0) goto <D.47817>; else goto <D.47818>;
            <D.47817>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4919, "tmp_klass");
            <D.47818>:
            <D.47811>:
          }
          obj_array.428 = tmp_klass;
        }
        obj_array = obj_array.428;
        helper = mono_marshal_get_virtual_stelemref (obj_array);
        D.47819 = helper->slot;
        if (D.47819 == 0) goto <D.47820>; else goto <D.47821>;
        <D.47820>:
        mono_class_setup_vtable (obj_array);
        <D.47821>:
        D.47819 = helper->slot;
        D.47822 = D.47819 == 0;
        D.47823 = (long int) D.47822;
        D.47824 = __builtin_expect (D.47823, 0);
        if (D.47824 != 0) goto <D.47825>; else goto <D.47826>;
        <D.47825>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4925, "helper->slot");
        <D.47826>:
        D.47827 = *sp;
        D.47828 = D.47827->type;
        if (D.47828 != 6) goto <D.47829>; else goto <D.47830>;
        <D.47829>:
        D.47831 = 0B;
        return D.47831;
        <D.47830>:
        D.47804 = sp + 16;
        D.47805 = *D.47804;
        D.47832 = D.47805->type;
        if (D.47832 != 6) goto <D.47833>; else goto <D.47834>;
        <D.47833>:
        D.47831 = 0B;
        return D.47831;
        <D.47834>:
        D.47835 = MEM[(struct MonoInst * *)sp + 16B];
        iargs[2] = D.47835;
        D.47836 = MEM[(struct MonoInst * *)sp + 8B];
        iargs[1] = D.47836;
        D.47827 = *sp;
        iargs[0] = D.47827;
        D.47827 = *sp;
        D.47831 = mono_emit_method_call (cfg, helper, &iargs, D.47827);
        return D.47831;
      }
    finally
      {
        iargs = {CLOBBER};
      }
  }
  <D.47799>:
  {
    struct MonoInst * ins;

    D.47837 = mini_is_gsharedvt_variable_klass (cfg, klass);
    if (D.47837 != 0) goto <D.47838>; else goto <D.47839>;
    <D.47838>:
    {
      struct MonoInst * addr;

      D.47827 = *sp;
      D.47840 = sp + 8;
      D.47841 = *D.47840;
      addr = mini_emit_ldelema_1_ins (cfg, klass, D.47827, D.47841, 1);
      D.47842 = cfg->mempool;
      ins = mono_mempool_alloc (D.47842, 80);
      ins->data.op[1].const_val = 0;
      D.47843 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.47843;
      ins->prev = 0B;
      D.47844 = ins->prev;
      ins->next = D.47844;
      D.47845 = &klass->byval_arg;
      D.47846 = mono_type_to_store_membase (cfg, D.47845);
      D.47847 = (short unsigned int) D.47846;
      ins->opcode = D.47847;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.47848 = ins->sreg3;
      ins->sreg2 = D.47848;
      D.47849 = ins->sreg2;
      ins->sreg1 = D.47849;
      D.47850 = cfg->ip;
      ins->cil_code = D.47850;
      D.47804 = sp + 16;
      D.47805 = *D.47804;
      D.47851 = D.47805->dreg;
      ins->sreg1 = D.47851;
      D.47852 = addr->dreg;
      ins->dreg = D.47852;
      ins->data.op[0].const_val = 0;
      D.47845 = &klass->byval_arg;
      type_to_eval_stack_type (cfg, D.47845, ins);
      D.47845 = &klass->byval_arg;
      D.47853 = mono_class_from_mono_type (D.47845);
      ins->klass = D.47853;
      D.47854 = cfg->cbb;
      D.47855 = D.47854->last_ins;
      if (D.47855 != 0B) goto <D.47856>; else goto <D.47857>;
      <D.47856>:
      D.47854 = cfg->cbb;
      D.47855 = D.47854->last_ins;
      D.47855->next = ins;
      D.47854 = cfg->cbb;
      D.47855 = D.47854->last_ins;
      ins->prev = D.47855;
      D.47854 = cfg->cbb;
      D.47854->last_ins = ins;
      goto <D.47858>;
      <D.47857>:
      D.47854 = cfg->cbb;
      D.47854 = cfg->cbb;
      D.47854->last_ins = ins;
      D.47855 = D.47854->last_ins;
      D.47854->code = D.47855;
      <D.47858>:
      ins->opcode = 387;
    }
    goto <D.47859>;
    <D.47839>:
    D.47840 = sp + 8;
    D.47841 = *D.47840;
    D.47860 = D.47841->opcode;
    if (D.47860 == 362) goto <D.47861>; else goto <D.47862>;
    <D.47861>:
    {
      int array_reg;
      int index_reg;
      int offset;

      D.47827 = *sp;
      array_reg = D.47827->dreg;
      D.47840 = sp + 8;
      D.47841 = *D.47840;
      index_reg = D.47841->dreg;
      D.47863 = mono_class_array_element_size (klass);
      D.47864 = (unsigned int) D.47863;
      D.47840 = sp + 8;
      D.47841 = *D.47840;
      D.47865 = D.47841->data.op[0].const_val;
      D.47866 = (unsigned int) D.47865;
      D.47867 = D.47864 * D.47866;
      D.47868 = D.47867 + 32;
      offset = (int) D.47868;
      if (safety_checks != 0) goto <D.47869>; else goto <D.47870>;
      <D.47869>:
      D.47871 = cfg->opt;
      D.47872 = D.47871 & 134217728;
      if (D.47872 == 0) goto <D.47873>; else goto <D.47874>;
      <D.47873>:
      D.47871 = cfg->opt;
      D.47875 = D.47871 & 262144;
      if (D.47875 == 0) goto <D.47876>; else goto <D.47877>;
      <D.47876>:
      D.47878 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.47879 = D.47878 & 144115188075855872;
      if (D.47879 != 0) goto <D.47880>; else goto <D.47881>;
      <D.47880>:
      {
        struct MonoInst * inst;

        D.47842 = cfg->mempool;
        inst = mono_mempool_alloc (D.47842, 80);
        inst->data.op[1].const_val = 0;
        D.47882 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.47882;
        inst->prev = 0B;
        D.47883 = inst->prev;
        inst->next = D.47883;
        inst->opcode = 323;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.47884 = inst->sreg3;
        inst->sreg2 = D.47884;
        D.47885 = inst->sreg2;
        inst->sreg1 = D.47885;
        D.47850 = cfg->ip;
        inst->cil_code = D.47850;
        inst->dreg = -1;
        inst->sreg1 = array_reg;
        inst->data.op[1].const_val = 0;
        D.47854 = cfg->cbb;
        D.47855 = D.47854->last_ins;
        if (D.47855 != 0B) goto <D.47886>; else goto <D.47887>;
        <D.47886>:
        D.47854 = cfg->cbb;
        D.47855 = D.47854->last_ins;
        D.47855->next = inst;
        D.47854 = cfg->cbb;
        D.47855 = D.47854->last_ins;
        inst->prev = D.47855;
        D.47854 = cfg->cbb;
        D.47854->last_ins = inst;
        goto <D.47888>;
        <D.47887>:
        D.47854 = cfg->cbb;
        D.47854 = cfg->cbb;
        D.47854->last_ins = inst;
        D.47855 = D.47854->last_ins;
        D.47854->code = D.47855;
        <D.47888>:
      }
      {
        struct MonoInst * inst;

        D.47842 = cfg->mempool;
        inst = mono_mempool_alloc (D.47842, 80);
        inst->data.op[1].const_val = 0;
        D.47889 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.47889;
        inst->prev = 0B;
        D.47890 = inst->prev;
        inst->next = D.47890;
        inst->opcode = 451;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.47891 = inst->sreg3;
        inst->sreg2 = D.47891;
        D.47892 = inst->sreg2;
        inst->sreg1 = D.47892;
        D.47850 = cfg->ip;
        inst->cil_code = D.47850;
        inst->data.op[1].p = "NullReferenceException";
        D.47854 = cfg->cbb;
        D.47855 = D.47854->last_ins;
        if (D.47855 != 0B) goto <D.47893>; else goto <D.47894>;
        <D.47893>:
        D.47854 = cfg->cbb;
        D.47855 = D.47854->last_ins;
        D.47855->next = inst;
        D.47854 = cfg->cbb;
        D.47855 = D.47854->last_ins;
        inst->prev = D.47855;
        D.47854 = cfg->cbb;
        D.47854->last_ins = inst;
        goto <D.47895>;
        <D.47894>:
        D.47854 = cfg->cbb;
        D.47854 = cfg->cbb;
        D.47854->last_ins = inst;
        D.47855 = D.47854->last_ins;
        D.47854->code = D.47855;
        <D.47895>:
      }
      goto <D.47896>;
      <D.47881>:
      <D.47896>:
      if (0 != 0) goto <D.47897>; else goto <D.47898>;
      <D.47897>:
      {
        int _length_reg;

        D.47899 = alloc_ireg (cfg);
        _length_reg = (int) D.47899;
        if (1 != 0) goto <D.47900>; else goto <D.47901>;
        <D.47900>:
        {
          struct MonoInst * inst;
          int __ins_flags;

          __ins_flags = 32;
          D.47902 = __ins_flags & 32;
          if (D.47902 != 0) goto <D.47903>; else goto <D.47904>;
          <D.47903>:
          D.47878 = BIT_FIELD_REF <*cfg, 64, 5632>;
          D.47879 = D.47878 & 144115188075855872;
          if (D.47879 != 0) goto <D.47905>; else goto <D.47906>;
          <D.47905>:
          {
            struct MonoInst * inst;

            D.47842 = cfg->mempool;
            inst = mono_mempool_alloc (D.47842, 80);
            inst->data.op[1].const_val = 0;
            D.47907 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.47907;
            inst->prev = 0B;
            D.47908 = inst->prev;
            inst->next = D.47908;
            inst->opcode = 323;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.47909 = inst->sreg3;
            inst->sreg2 = D.47909;
            D.47910 = inst->sreg2;
            inst->sreg1 = D.47910;
            D.47850 = cfg->ip;
            inst->cil_code = D.47850;
            inst->dreg = -1;
            inst->sreg1 = array_reg;
            inst->data.op[1].const_val = 0;
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            if (D.47855 != 0B) goto <D.47911>; else goto <D.47912>;
            <D.47911>:
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            D.47855->next = inst;
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            inst->prev = D.47855;
            D.47854 = cfg->cbb;
            D.47854->last_ins = inst;
            goto <D.47913>;
            <D.47912>:
            D.47854 = cfg->cbb;
            D.47854 = cfg->cbb;
            D.47854->last_ins = inst;
            D.47855 = D.47854->last_ins;
            D.47854->code = D.47855;
            <D.47913>:
          }
          {
            struct MonoInst * inst;

            D.47842 = cfg->mempool;
            inst = mono_mempool_alloc (D.47842, 80);
            inst->data.op[1].const_val = 0;
            D.47914 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.47914;
            inst->prev = 0B;
            D.47915 = inst->prev;
            inst->next = D.47915;
            inst->opcode = 451;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.47916 = inst->sreg3;
            inst->sreg2 = D.47916;
            D.47917 = inst->sreg2;
            inst->sreg1 = D.47917;
            D.47850 = cfg->ip;
            inst->cil_code = D.47850;
            inst->data.op[1].p = "NullReferenceException";
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            if (D.47855 != 0B) goto <D.47918>; else goto <D.47919>;
            <D.47918>:
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            D.47855->next = inst;
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            inst->prev = D.47855;
            D.47854 = cfg->cbb;
            D.47854->last_ins = inst;
            goto <D.47920>;
            <D.47919>:
            D.47854 = cfg->cbb;
            D.47854 = cfg->cbb;
            D.47854->last_ins = inst;
            D.47855 = D.47854->last_ins;
            D.47854->code = D.47855;
            <D.47920>:
          }
          goto <D.47921>;
          <D.47906>:
          <D.47921>:
          <D.47904>:
          D.47842 = cfg->mempool;
          inst = mono_mempool_alloc (D.47842, 80);
          inst->data.op[1].const_val = 0;
          D.47922 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.47922;
          inst->prev = 0B;
          D.47923 = inst->prev;
          inst->next = D.47923;
          inst->opcode = 393;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.47924 = inst->sreg3;
          inst->sreg2 = D.47924;
          D.47925 = inst->sreg2;
          inst->sreg1 = D.47925;
          D.47850 = cfg->ip;
          inst->cil_code = D.47850;
          inst->dreg = _length_reg;
          inst->sreg1 = array_reg;
          inst->data.op[0].const_val = 24;
          inst->type = 1;
          D.47926 = (unsigned char) __ins_flags;
          inst->flags = D.47926;
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          if (D.47855 != 0B) goto <D.47927>; else goto <D.47928>;
          <D.47927>:
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          D.47855->next = inst;
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          inst->prev = D.47855;
          D.47854 = cfg->cbb;
          D.47854->last_ins = inst;
          goto <D.47929>;
          <D.47928>:
          D.47854 = cfg->cbb;
          D.47854 = cfg->cbb;
          D.47854->last_ins = inst;
          D.47855 = D.47854->last_ins;
          D.47854->code = D.47855;
          <D.47929>:
        }
        goto <D.47930>;
        <D.47901>:
        {
          struct MonoInst * inst;
          int __ins_flags;

          __ins_flags = 64;
          D.47931 = __ins_flags & 32;
          if (D.47931 != 0) goto <D.47932>; else goto <D.47933>;
          <D.47932>:
          D.47878 = BIT_FIELD_REF <*cfg, 64, 5632>;
          D.47879 = D.47878 & 144115188075855872;
          if (D.47879 != 0) goto <D.47934>; else goto <D.47935>;
          <D.47934>:
          {
            struct MonoInst * inst;

            D.47842 = cfg->mempool;
            inst = mono_mempool_alloc (D.47842, 80);
            inst->data.op[1].const_val = 0;
            D.47936 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.47936;
            inst->prev = 0B;
            D.47937 = inst->prev;
            inst->next = D.47937;
            inst->opcode = 323;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.47938 = inst->sreg3;
            inst->sreg2 = D.47938;
            D.47939 = inst->sreg2;
            inst->sreg1 = D.47939;
            D.47850 = cfg->ip;
            inst->cil_code = D.47850;
            inst->dreg = -1;
            inst->sreg1 = array_reg;
            inst->data.op[1].const_val = 0;
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            if (D.47855 != 0B) goto <D.47940>; else goto <D.47941>;
            <D.47940>:
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            D.47855->next = inst;
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            inst->prev = D.47855;
            D.47854 = cfg->cbb;
            D.47854->last_ins = inst;
            goto <D.47942>;
            <D.47941>:
            D.47854 = cfg->cbb;
            D.47854 = cfg->cbb;
            D.47854->last_ins = inst;
            D.47855 = D.47854->last_ins;
            D.47854->code = D.47855;
            <D.47942>:
          }
          {
            struct MonoInst * inst;

            D.47842 = cfg->mempool;
            inst = mono_mempool_alloc (D.47842, 80);
            inst->data.op[1].const_val = 0;
            D.47943 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.47943;
            inst->prev = 0B;
            D.47944 = inst->prev;
            inst->next = D.47944;
            inst->opcode = 451;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.47945 = inst->sreg3;
            inst->sreg2 = D.47945;
            D.47946 = inst->sreg2;
            inst->sreg1 = D.47946;
            D.47850 = cfg->ip;
            inst->cil_code = D.47850;
            inst->data.op[1].p = "NullReferenceException";
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            if (D.47855 != 0B) goto <D.47947>; else goto <D.47948>;
            <D.47947>:
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            D.47855->next = inst;
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            inst->prev = D.47855;
            D.47854 = cfg->cbb;
            D.47854->last_ins = inst;
            goto <D.47949>;
            <D.47948>:
            D.47854 = cfg->cbb;
            D.47854 = cfg->cbb;
            D.47854->last_ins = inst;
            D.47855 = D.47854->last_ins;
            D.47854->code = D.47855;
            <D.47949>:
          }
          goto <D.47950>;
          <D.47935>:
          <D.47950>:
          <D.47933>:
          D.47842 = cfg->mempool;
          inst = mono_mempool_alloc (D.47842, 80);
          inst->data.op[1].const_val = 0;
          D.47951 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.47951;
          inst->prev = 0B;
          D.47952 = inst->prev;
          inst->next = D.47952;
          inst->opcode = 393;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.47953 = inst->sreg3;
          inst->sreg2 = D.47953;
          D.47954 = inst->sreg2;
          inst->sreg1 = D.47954;
          D.47850 = cfg->ip;
          inst->cil_code = D.47850;
          inst->dreg = _length_reg;
          inst->sreg1 = array_reg;
          inst->data.op[0].const_val = 24;
          inst->type = 1;
          D.47955 = (unsigned char) __ins_flags;
          inst->flags = D.47955;
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          if (D.47855 != 0B) goto <D.47956>; else goto <D.47957>;
          <D.47956>:
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          D.47855->next = inst;
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          inst->prev = D.47855;
          D.47854 = cfg->cbb;
          D.47854->last_ins = inst;
          goto <D.47958>;
          <D.47957>:
          D.47854 = cfg->cbb;
          D.47854 = cfg->cbb;
          D.47854->last_ins = inst;
          D.47855 = D.47854->last_ins;
          D.47854->code = D.47855;
          <D.47958>:
        }
        <D.47930>:
        {
          struct MonoInst * inst;

          D.47842 = cfg->mempool;
          inst = mono_mempool_alloc (D.47842, 80);
          inst->data.op[1].const_val = 0;
          D.47959 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.47959;
          inst->prev = 0B;
          D.47960 = inst->prev;
          inst->next = D.47960;
          inst->opcode = 322;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.47961 = inst->sreg3;
          inst->sreg2 = D.47961;
          D.47962 = inst->sreg2;
          inst->sreg1 = D.47962;
          D.47850 = cfg->ip;
          inst->cil_code = D.47850;
          inst->dreg = -1;
          inst->sreg1 = _length_reg;
          inst->sreg2 = index_reg;
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          if (D.47855 != 0B) goto <D.47963>; else goto <D.47964>;
          <D.47963>:
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          D.47855->next = inst;
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          inst->prev = D.47855;
          D.47854 = cfg->cbb;
          D.47854->last_ins = inst;
          goto <D.47965>;
          <D.47964>:
          D.47854 = cfg->cbb;
          D.47854 = cfg->cbb;
          D.47854->last_ins = inst;
          D.47855 = D.47854->last_ins;
          D.47854->code = D.47855;
          <D.47965>:
        }
        {
          struct MonoInst * inst;

          D.47842 = cfg->mempool;
          inst = mono_mempool_alloc (D.47842, 80);
          inst->data.op[1].const_val = 0;
          D.47966 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.47966;
          inst->prev = 0B;
          D.47967 = inst->prev;
          inst->next = D.47967;
          inst->opcode = 459;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.47968 = inst->sreg3;
          inst->sreg2 = D.47968;
          D.47969 = inst->sreg2;
          inst->sreg1 = D.47969;
          D.47850 = cfg->ip;
          inst->cil_code = D.47850;
          inst->data.op[1].p = "IndexOutOfRangeException";
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          if (D.47855 != 0B) goto <D.47970>; else goto <D.47971>;
          <D.47970>:
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          D.47855->next = inst;
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          inst->prev = D.47855;
          D.47854 = cfg->cbb;
          D.47854->last_ins = inst;
          goto <D.47972>;
          <D.47971>:
          D.47854 = cfg->cbb;
          D.47854 = cfg->cbb;
          D.47854->last_ins = inst;
          D.47855 = D.47854->last_ins;
          D.47854->code = D.47855;
          <D.47972>:
        }
      }
      goto <D.47973>;
      <D.47898>:
      {
        int _length_reg;

        D.47974 = alloc_ireg (cfg);
        _length_reg = (int) D.47974;
        if (1 != 0) goto <D.47975>; else goto <D.47976>;
        <D.47975>:
        {
          struct MonoInst * inst;
          int __ins_flags;

          __ins_flags = 32;
          D.47977 = __ins_flags & 32;
          if (D.47977 != 0) goto <D.47978>; else goto <D.47979>;
          <D.47978>:
          D.47878 = BIT_FIELD_REF <*cfg, 64, 5632>;
          D.47879 = D.47878 & 144115188075855872;
          if (D.47879 != 0) goto <D.47980>; else goto <D.47981>;
          <D.47980>:
          {
            struct MonoInst * inst;

            D.47842 = cfg->mempool;
            inst = mono_mempool_alloc (D.47842, 80);
            inst->data.op[1].const_val = 0;
            D.47982 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.47982;
            inst->prev = 0B;
            D.47983 = inst->prev;
            inst->next = D.47983;
            inst->opcode = 323;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.47984 = inst->sreg3;
            inst->sreg2 = D.47984;
            D.47985 = inst->sreg2;
            inst->sreg1 = D.47985;
            D.47850 = cfg->ip;
            inst->cil_code = D.47850;
            inst->dreg = -1;
            inst->sreg1 = array_reg;
            inst->data.op[1].const_val = 0;
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            if (D.47855 != 0B) goto <D.47986>; else goto <D.47987>;
            <D.47986>:
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            D.47855->next = inst;
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            inst->prev = D.47855;
            D.47854 = cfg->cbb;
            D.47854->last_ins = inst;
            goto <D.47988>;
            <D.47987>:
            D.47854 = cfg->cbb;
            D.47854 = cfg->cbb;
            D.47854->last_ins = inst;
            D.47855 = D.47854->last_ins;
            D.47854->code = D.47855;
            <D.47988>:
          }
          {
            struct MonoInst * inst;

            D.47842 = cfg->mempool;
            inst = mono_mempool_alloc (D.47842, 80);
            inst->data.op[1].const_val = 0;
            D.47989 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.47989;
            inst->prev = 0B;
            D.47990 = inst->prev;
            inst->next = D.47990;
            inst->opcode = 451;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.47991 = inst->sreg3;
            inst->sreg2 = D.47991;
            D.47992 = inst->sreg2;
            inst->sreg1 = D.47992;
            D.47850 = cfg->ip;
            inst->cil_code = D.47850;
            inst->data.op[1].p = "NullReferenceException";
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            if (D.47855 != 0B) goto <D.47993>; else goto <D.47994>;
            <D.47993>:
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            D.47855->next = inst;
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            inst->prev = D.47855;
            D.47854 = cfg->cbb;
            D.47854->last_ins = inst;
            goto <D.47995>;
            <D.47994>:
            D.47854 = cfg->cbb;
            D.47854 = cfg->cbb;
            D.47854->last_ins = inst;
            D.47855 = D.47854->last_ins;
            D.47854->code = D.47855;
            <D.47995>:
          }
          goto <D.47996>;
          <D.47981>:
          <D.47996>:
          <D.47979>:
          D.47842 = cfg->mempool;
          inst = mono_mempool_alloc (D.47842, 80);
          inst->data.op[1].const_val = 0;
          D.47997 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.47997;
          inst->prev = 0B;
          D.47998 = inst->prev;
          inst->next = D.47998;
          inst->opcode = 393;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.47999 = inst->sreg3;
          inst->sreg2 = D.47999;
          D.48000 = inst->sreg2;
          inst->sreg1 = D.48000;
          D.47850 = cfg->ip;
          inst->cil_code = D.47850;
          inst->dreg = _length_reg;
          inst->sreg1 = array_reg;
          inst->data.op[0].const_val = 24;
          inst->type = 1;
          D.48001 = (unsigned char) __ins_flags;
          inst->flags = D.48001;
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          if (D.47855 != 0B) goto <D.48002>; else goto <D.48003>;
          <D.48002>:
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          D.47855->next = inst;
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          inst->prev = D.47855;
          D.47854 = cfg->cbb;
          D.47854->last_ins = inst;
          goto <D.48004>;
          <D.48003>:
          D.47854 = cfg->cbb;
          D.47854 = cfg->cbb;
          D.47854->last_ins = inst;
          D.47855 = D.47854->last_ins;
          D.47854->code = D.47855;
          <D.48004>:
        }
        goto <D.48005>;
        <D.47976>:
        {
          struct MonoInst * inst;
          int __ins_flags;

          __ins_flags = 64;
          D.48006 = __ins_flags & 32;
          if (D.48006 != 0) goto <D.48007>; else goto <D.48008>;
          <D.48007>:
          D.47878 = BIT_FIELD_REF <*cfg, 64, 5632>;
          D.47879 = D.47878 & 144115188075855872;
          if (D.47879 != 0) goto <D.48009>; else goto <D.48010>;
          <D.48009>:
          {
            struct MonoInst * inst;

            D.47842 = cfg->mempool;
            inst = mono_mempool_alloc (D.47842, 80);
            inst->data.op[1].const_val = 0;
            D.48011 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.48011;
            inst->prev = 0B;
            D.48012 = inst->prev;
            inst->next = D.48012;
            inst->opcode = 323;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.48013 = inst->sreg3;
            inst->sreg2 = D.48013;
            D.48014 = inst->sreg2;
            inst->sreg1 = D.48014;
            D.47850 = cfg->ip;
            inst->cil_code = D.47850;
            inst->dreg = -1;
            inst->sreg1 = array_reg;
            inst->data.op[1].const_val = 0;
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            if (D.47855 != 0B) goto <D.48015>; else goto <D.48016>;
            <D.48015>:
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            D.47855->next = inst;
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            inst->prev = D.47855;
            D.47854 = cfg->cbb;
            D.47854->last_ins = inst;
            goto <D.48017>;
            <D.48016>:
            D.47854 = cfg->cbb;
            D.47854 = cfg->cbb;
            D.47854->last_ins = inst;
            D.47855 = D.47854->last_ins;
            D.47854->code = D.47855;
            <D.48017>:
          }
          {
            struct MonoInst * inst;

            D.47842 = cfg->mempool;
            inst = mono_mempool_alloc (D.47842, 80);
            inst->data.op[1].const_val = 0;
            D.48018 = inst->data.op[1].const_val;
            inst->data.op[0].const_val = D.48018;
            inst->prev = 0B;
            D.48019 = inst->prev;
            inst->next = D.48019;
            inst->opcode = 451;
            inst->flags = 0;
            inst->type = 0;
            inst->dreg = -1;
            inst->sreg3 = -1;
            D.48020 = inst->sreg3;
            inst->sreg2 = D.48020;
            D.48021 = inst->sreg2;
            inst->sreg1 = D.48021;
            D.47850 = cfg->ip;
            inst->cil_code = D.47850;
            inst->data.op[1].p = "NullReferenceException";
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            if (D.47855 != 0B) goto <D.48022>; else goto <D.48023>;
            <D.48022>:
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            D.47855->next = inst;
            D.47854 = cfg->cbb;
            D.47855 = D.47854->last_ins;
            inst->prev = D.47855;
            D.47854 = cfg->cbb;
            D.47854->last_ins = inst;
            goto <D.48024>;
            <D.48023>:
            D.47854 = cfg->cbb;
            D.47854 = cfg->cbb;
            D.47854->last_ins = inst;
            D.47855 = D.47854->last_ins;
            D.47854->code = D.47855;
            <D.48024>:
          }
          goto <D.48025>;
          <D.48010>:
          <D.48025>:
          <D.48008>:
          D.47842 = cfg->mempool;
          inst = mono_mempool_alloc (D.47842, 80);
          inst->data.op[1].const_val = 0;
          D.48026 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.48026;
          inst->prev = 0B;
          D.48027 = inst->prev;
          inst->next = D.48027;
          inst->opcode = 393;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.48028 = inst->sreg3;
          inst->sreg2 = D.48028;
          D.48029 = inst->sreg2;
          inst->sreg1 = D.48029;
          D.47850 = cfg->ip;
          inst->cil_code = D.47850;
          inst->dreg = _length_reg;
          inst->sreg1 = array_reg;
          inst->data.op[0].const_val = 24;
          inst->type = 1;
          D.48030 = (unsigned char) __ins_flags;
          inst->flags = D.48030;
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          if (D.47855 != 0B) goto <D.48031>; else goto <D.48032>;
          <D.48031>:
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          D.47855->next = inst;
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          inst->prev = D.47855;
          D.47854 = cfg->cbb;
          D.47854->last_ins = inst;
          goto <D.48033>;
          <D.48032>:
          D.47854 = cfg->cbb;
          D.47854 = cfg->cbb;
          D.47854->last_ins = inst;
          D.47855 = D.47854->last_ins;
          D.47854->code = D.47855;
          <D.48033>:
        }
        <D.48005>:
        {
          struct MonoInst * inst;

          D.47842 = cfg->mempool;
          inst = mono_mempool_alloc (D.47842, 80);
          inst->data.op[1].const_val = 0;
          D.48034 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.48034;
          inst->prev = 0B;
          D.48035 = inst->prev;
          inst->next = D.48035;
          inst->opcode = 322;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.48036 = inst->sreg3;
          inst->sreg2 = D.48036;
          D.48037 = inst->sreg2;
          inst->sreg1 = D.48037;
          D.47850 = cfg->ip;
          inst->cil_code = D.47850;
          inst->dreg = -1;
          inst->sreg1 = _length_reg;
          inst->sreg2 = index_reg;
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          if (D.47855 != 0B) goto <D.48038>; else goto <D.48039>;
          <D.48038>:
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          D.47855->next = inst;
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          inst->prev = D.47855;
          D.47854 = cfg->cbb;
          D.47854->last_ins = inst;
          goto <D.48040>;
          <D.48039>:
          D.47854 = cfg->cbb;
          D.47854 = cfg->cbb;
          D.47854->last_ins = inst;
          D.47855 = D.47854->last_ins;
          D.47854->code = D.47855;
          <D.48040>:
        }
        {
          struct MonoInst * inst;

          D.47842 = cfg->mempool;
          inst = mono_mempool_alloc (D.47842, 80);
          inst->data.op[1].const_val = 0;
          D.48041 = inst->data.op[1].const_val;
          inst->data.op[0].const_val = D.48041;
          inst->prev = 0B;
          D.48042 = inst->prev;
          inst->next = D.48042;
          inst->opcode = 459;
          inst->flags = 0;
          inst->type = 0;
          inst->dreg = -1;
          inst->sreg3 = -1;
          D.48043 = inst->sreg3;
          inst->sreg2 = D.48043;
          D.48044 = inst->sreg2;
          inst->sreg1 = D.48044;
          D.47850 = cfg->ip;
          inst->cil_code = D.47850;
          inst->data.op[1].p = "IndexOutOfRangeException";
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          if (D.47855 != 0B) goto <D.48045>; else goto <D.48046>;
          <D.48045>:
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          D.47855->next = inst;
          D.47854 = cfg->cbb;
          D.47855 = D.47854->last_ins;
          inst->prev = D.47855;
          D.47854 = cfg->cbb;
          D.47854->last_ins = inst;
          goto <D.48047>;
          <D.48046>:
          D.47854 = cfg->cbb;
          D.47854 = cfg->cbb;
          D.47854->last_ins = inst;
          D.47855 = D.47854->last_ins;
          D.47854->code = D.47855;
          <D.48047>:
        }
      }
      <D.47973>:
      goto <D.48048>;
      <D.47877>:
      {
        struct MonoInst * ins;

        D.47842 = cfg->mempool;
        ins = mono_mempool_alloc (D.47842, 80);
        ins->data.op[1].const_val = 0;
        D.48049 = ins->data.op[1].const_val;
        ins->data.op[0].const_val = D.48049;
        ins->prev = 0B;
        D.48050 = ins->prev;
        ins->next = D.48050;
        ins->opcode = 784;
        ins->flags = 0;
        ins->type = 0;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.48051 = ins->sreg3;
        ins->sreg2 = D.48051;
        D.48052 = ins->sreg2;
        ins->sreg1 = D.48052;
        D.47850 = cfg->ip;
        ins->cil_code = D.47850;
        ins->sreg1 = array_reg;
        ins->sreg2 = index_reg;
        ins->data.op[1].const_val = 24;
        D.48053 = ins->flags;
        D.48054 = D.48053 | 32;
        ins->flags = D.48054;
        D.47854 = cfg->cbb;
        D.47855 = D.47854->last_ins;
        if (D.47855 != 0B) goto <D.48055>; else goto <D.48056>;
        <D.48055>:
        D.47854 = cfg->cbb;
        D.47855 = D.47854->last_ins;
        D.47855->next = ins;
        D.47854 = cfg->cbb;
        D.47855 = D.47854->last_ins;
        ins->prev = D.47855;
        D.47854 = cfg->cbb;
        D.47854->last_ins = ins;
        goto <D.48057>;
        <D.48056>:
        D.47854 = cfg->cbb;
        D.47854 = cfg->cbb;
        D.47854->last_ins = ins;
        D.47855 = D.47854->last_ins;
        D.47854->code = D.47855;
        <D.48057>:
        D.48058 = cfg->flags;
        D.48059 = D.48058 | 256;
        cfg->flags = D.48059;
        D.47854 = cfg->cbb;
        D.47854->has_array_access = 1;
      }
      <D.48048>:
      <D.47874>:
      <D.47870>:
      D.47842 = cfg->mempool;
      ins = mono_mempool_alloc (D.47842, 80);
      ins->data.op[1].const_val = 0;
      D.47843 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.47843;
      ins->prev = 0B;
      D.47844 = ins->prev;
      ins->next = D.47844;
      D.47845 = &klass->byval_arg;
      D.48060 = mono_type_to_store_membase (cfg, D.47845);
      D.48061 = (short unsigned int) D.48060;
      ins->opcode = D.48061;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.47848 = ins->sreg3;
      ins->sreg2 = D.47848;
      D.47849 = ins->sreg2;
      ins->sreg1 = D.47849;
      D.47850 = cfg->ip;
      ins->cil_code = D.47850;
      D.47804 = sp + 16;
      D.47805 = *D.47804;
      D.47851 = D.47805->dreg;
      ins->sreg1 = D.47851;
      ins->dreg = array_reg;
      D.48062 = (long int) offset;
      ins->data.op[0].const_val = D.48062;
      D.47845 = &klass->byval_arg;
      type_to_eval_stack_type (cfg, D.47845, ins);
      D.47845 = &klass->byval_arg;
      D.48063 = mono_class_from_mono_type (D.47845);
      ins->klass = D.48063;
      D.47854 = cfg->cbb;
      D.47855 = D.47854->last_ins;
      if (D.47855 != 0B) goto <D.48064>; else goto <D.48065>;
      <D.48064>:
      D.47854 = cfg->cbb;
      D.47855 = D.47854->last_ins;
      D.47855->next = ins;
      D.47854 = cfg->cbb;
      D.47855 = D.47854->last_ins;
      ins->prev = D.47855;
      D.47854 = cfg->cbb;
      D.47854->last_ins = ins;
      goto <D.48066>;
      <D.48065>:
      D.47854 = cfg->cbb;
      D.47854 = cfg->cbb;
      D.47854->last_ins = ins;
      D.47855 = D.47854->last_ins;
      D.47854->code = D.47855;
      <D.48066>:
    }
    goto <D.48067>;
    <D.47862>:
    {
      struct MonoInst * addr;

      D.47827 = *sp;
      D.47840 = sp + 8;
      D.47841 = *D.47840;
      addr = mini_emit_ldelema_1_ins (cfg, klass, D.47827, D.47841, safety_checks);
      D.47842 = cfg->mempool;
      ins = mono_mempool_alloc (D.47842, 80);
      ins->data.op[1].const_val = 0;
      D.47843 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.47843;
      ins->prev = 0B;
      D.47844 = ins->prev;
      ins->next = D.47844;
      D.47845 = &klass->byval_arg;
      D.48068 = mono_type_to_store_membase (cfg, D.47845);
      D.48069 = (short unsigned int) D.48068;
      ins->opcode = D.48069;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.47848 = ins->sreg3;
      ins->sreg2 = D.47848;
      D.47849 = ins->sreg2;
      ins->sreg1 = D.47849;
      D.47850 = cfg->ip;
      ins->cil_code = D.47850;
      D.47804 = sp + 16;
      D.47805 = *D.47804;
      D.47851 = D.47805->dreg;
      ins->sreg1 = D.47851;
      D.48070 = addr->dreg;
      ins->dreg = D.48070;
      ins->data.op[0].const_val = 0;
      D.47845 = &klass->byval_arg;
      type_to_eval_stack_type (cfg, D.47845, ins);
      D.47845 = &klass->byval_arg;
      D.48071 = mono_class_from_mono_type (D.47845);
      ins->klass = D.48071;
      D.47854 = cfg->cbb;
      D.47855 = D.47854->last_ins;
      if (D.47855 != 0B) goto <D.48072>; else goto <D.48073>;
      <D.48072>:
      D.47854 = cfg->cbb;
      D.47855 = D.47854->last_ins;
      D.47855->next = ins;
      D.47854 = cfg->cbb;
      D.47855 = D.47854->last_ins;
      ins->prev = D.47855;
      D.47854 = cfg->cbb;
      D.47854->last_ins = ins;
      goto <D.48074>;
      <D.48073>:
      D.47854 = cfg->cbb;
      D.47854 = cfg->cbb;
      D.47854->last_ins = ins;
      D.47855 = D.47854->last_ins;
      D.47854->code = D.47855;
      <D.48074>:
      D.48075 = generic_class_is_reference_type (cfg, klass);
      if (D.48075 != 0) goto <D.48076>; else goto <D.48077>;
      <D.48076>:
      D.47804 = sp + 16;
      D.47805 = *D.47804;
      emit_write_barrier (cfg, addr, D.47805);
      <D.48077>:
    }
    <D.48067>:
    <D.47859>:
    D.47831 = ins;
    return D.47831;
  }
}


mini_emit_class_check (struct MonoCompile * cfg, int klass_reg, struct MonoClass * klass)
{
  mini_emit_class_check_inst (cfg, klass_reg, klass, 0B);
}


emit_get_rgctx_field (struct MonoCompile * cfg, int context_used, struct MonoClassField * field, MonoRgctxInfoType rgctx_type)
{
  struct MonoMemPool * D.48080;
  struct MonoMethod * D.48081;
  int D.48082;
  struct MonoInst * D.48083;
  struct MonoJumpInfoRgctxEntry * entry;
  struct MonoInst * rgctx;

  D.48080 = cfg->mempool;
  D.48081 = cfg->current_method;
  D.48082 = context_used & 2;
  entry = mono_patch_info_rgctx_entry_new (D.48080, D.48081, D.48082, 13, field, rgctx_type);
  D.48081 = cfg->current_method;
  rgctx = emit_get_rgctx (cfg, D.48081, context_used);
  D.48083 = emit_rgctx_fetch (cfg, rgctx, entry);
  return D.48083;
}


emit_seq_point (struct MonoCompile * cfg, struct MonoMethod * method, guint8 * ip, gboolean intr_loc, gboolean nonempty_stack)
{
  long unsigned int D.48085;
  long unsigned int D.48086;
  struct MonoMethod * D.48089;
  struct MonoMemPool * D.48092;
  long int D.48093;
  struct MonoInst * D.48094;
  int D.48095;
  int D.48096;
  const unsigned char * D.48097;
  long int ip.429;
  struct MonoMethodHeader * D.48099;
  const unsigned char * D.48100;
  long int D.48101;
  long int D.48102;
  _Bool D.48103;
  unsigned char D.48104;
  unsigned char D.48107;
  unsigned char D.48108;
  struct MonoBasicBlock * D.48109;
  struct MonoInst * D.48110;
  struct MonoInst * ins;

  D.48085 = BIT_FIELD_REF <*cfg, 64, 5632>;
  D.48086 = D.48085 & 288230376151711744;
  if (D.48086 != 0) goto <D.48087>; else goto <D.48088>;
  <D.48087>:
  D.48089 = cfg->method;
  if (D.48089 == method) goto <D.48090>; else goto <D.48091>;
  <D.48090>:
  D.48092 = cfg->mempool;
  ins = mono_mempool_alloc (D.48092, 80);
  ins->data.op[1].const_val = 0;
  D.48093 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.48093;
  ins->prev = 0B;
  D.48094 = ins->prev;
  ins->next = D.48094;
  ins->opcode = 341;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.48095 = ins->sreg3;
  ins->sreg2 = D.48095;
  D.48096 = ins->sreg2;
  ins->sreg1 = D.48096;
  D.48097 = cfg->ip;
  ins->cil_code = D.48097;
  ip.429 = (long int) ip;
  D.48099 = cfg->header;
  D.48100 = D.48099->code;
  D.48101 = (long int) D.48100;
  D.48102 = ip.429 - D.48101;
  ins->data.op[1].const_val = D.48102;
  D.48103 = intr_loc != 0;
  D.48104 = (unsigned char) D.48103;
  ins->flags = D.48104;
  if (nonempty_stack != 0) goto <D.48105>; else goto <D.48106>;
  <D.48105>:
  D.48107 = ins->flags;
  D.48108 = D.48107 | 4;
  ins->flags = D.48108;
  <D.48106>:
  D.48109 = cfg->cbb;
  D.48110 = D.48109->last_ins;
  if (D.48110 != 0B) goto <D.48111>; else goto <D.48112>;
  <D.48111>:
  D.48109 = cfg->cbb;
  D.48110 = D.48109->last_ins;
  D.48110->next = ins;
  D.48109 = cfg->cbb;
  D.48110 = D.48109->last_ins;
  ins->prev = D.48110;
  D.48109 = cfg->cbb;
  D.48109->last_ins = ins;
  goto <D.48113>;
  <D.48112>:
  D.48109 = cfg->cbb;
  D.48109 = cfg->cbb;
  D.48109->last_ins = ins;
  D.48110 = D.48109->last_ins;
  D.48109->code = D.48110;
  <D.48113>:
  <D.48091>:
  <D.48088>:
}


mono_find_final_block (struct MonoCompile * cfg, unsigned char * ip, unsigned char * target, int type)
{
  struct MonoExceptionClause * D.48114;
  long unsigned int D.48115;
  long unsigned int D.48116;
  unsigned int D.48119;
  long int D.48120;
  long int ip.430;
  const unsigned char * D.48122;
  long int D.48123;
  long int D.48124;
  unsigned int D.48127;
  unsigned int D.48128;
  long int D.48129;
  long int target.431;
  long int D.48133;
  unsigned int D.48135;
  unsigned int type.432;
  <unnamed-unsigned:15> D.48139;
  int D.48140;
  struct GList * D.48141;
  struct MonoMethodHeader * header;
  struct MonoExceptionClause * clause;
  int i;
  struct GList * res;

  header = cfg->header;
  res = 0B;
  i = 0;
  goto <D.25100>;
  <D.25099>:
  D.48114 = header->clauses;
  D.48115 = (long unsigned int) i;
  D.48116 = D.48115 * 32;
  clause = D.48114 + D.48116;
  D.48119 = clause->try_offset;
  D.48120 = (long int) D.48119;
  ip.430 = (long int) ip;
  D.48122 = header->code;
  D.48123 = (long int) D.48122;
  D.48124 = ip.430 - D.48123;
  if (D.48120 <= D.48124) goto <D.48125>; else goto <D.48126>;
  <D.48125>:
  ip.430 = (long int) ip;
  D.48122 = header->code;
  D.48123 = (long int) D.48122;
  D.48124 = ip.430 - D.48123;
  D.48119 = clause->try_offset;
  D.48127 = clause->try_len;
  D.48128 = D.48119 + D.48127;
  D.48129 = (long int) D.48128;
  if (D.48124 < D.48129) goto <D.48130>; else goto <D.48131>;
  <D.48130>:
  D.48119 = clause->try_offset;
  D.48120 = (long int) D.48119;
  target.431 = (long int) target;
  D.48122 = header->code;
  D.48123 = (long int) D.48122;
  D.48133 = target.431 - D.48123;
  if (D.48120 > D.48133) goto <D.48117>; else goto <D.48134>;
  <D.48134>:
  target.431 = (long int) target;
  D.48122 = header->code;
  D.48123 = (long int) D.48122;
  D.48133 = target.431 - D.48123;
  D.48119 = clause->try_offset;
  D.48127 = clause->try_len;
  D.48128 = D.48119 + D.48127;
  D.48129 = (long int) D.48128;
  if (D.48133 >= D.48129) goto <D.48117>; else goto <D.48118>;
  <D.48117>:
  D.48135 = clause->flags;
  type.432 = (unsigned int) type;
  if (D.48135 == type.432) goto <D.48137>; else goto <D.48138>;
  <D.48137>:
  res = monoeg_g_list_append (res, clause);
  <D.48138>:
  <D.48118>:
  <D.48131>:
  <D.48126>:
  i = i + 1;
  <D.25100>:
  D.48139 = header->num_clauses;
  D.48140 = (int) D.48139;
  if (D.48140 > i) goto <D.25099>; else goto <D.25101>;
  <D.25101>:
  D.48141 = res;
  return D.48141;
}


mono_get_domainvar (struct MonoCompile * cfg)
{
  struct MonoInst * D.48143;
  struct MonoClass * D.48146;
  struct MonoType * D.48147;
  struct MonoInst * D.48148;
  struct MonoInst * D.48149;

  D.48143 = cfg->domainvar;
  if (D.48143 == 0B) goto <D.48144>; else goto <D.48145>;
  <D.48144>:
  D.48146 = mono_defaults.int_class;
  D.48147 = &D.48146->byval_arg;
  D.48148 = mono_compile_create_var (cfg, D.48147, 329);
  cfg->domainvar = D.48148;
  <D.48145>:
  D.48149 = cfg->domainvar;
  return D.48149;
}


handle_cisinst (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * src)
{
  unsigned int D.48151;
  unsigned int D.48152;
  struct MonoMemPool * D.48153;
  unsigned int D.48154;
  unsigned int D.48155;
  unsigned int D.48156;
  int D.48157;
  unsigned int D.48158;
  unsigned int D.48159;
  int D.48160;
  unsigned int D.48161;
  unsigned int D.48162;
  int D.48163;
  unsigned int D.48164;
  unsigned int D.48165;
  int D.48166;
  unsigned int D.48167;
  unsigned int D.48168;
  int D.48169;
  long int D.48170;
  struct MonoInst * D.48171;
  int D.48172;
  int D.48173;
  const unsigned char * D.48174;
  struct MonoBasicBlock * D.48175;
  struct MonoInst * D.48176;
  long int D.48180;
  struct MonoInst * D.48181;
  int D.48182;
  int D.48183;
  unsigned int D.48186;
  unsigned int D.48187;
  int D.48188;
  unsigned char * D.48192;
  struct MonoBasicBlock * * D.48195;
  long int D.48196;
  unsigned char * D.48197;
  long int D.48198;
  long int D.48199;
  long unsigned int D.48200;
  long unsigned int D.48201;
  struct MonoBasicBlock * * D.48202;
  unsigned int D.48203;
  short unsigned int D.48208;
  short unsigned int D.48209;
  short unsigned int D.48211;
  short unsigned int D.48213;
  struct MonoBasicBlock * * D.48214;
  struct MonoBasicBlock * * D.48215;
  struct MonoBasicBlock * D.48216;
  void * D.48226;
  struct MonoBasicBlock * * D.48227;
  struct MonoBasicBlock * * D.48228;
  long unsigned int D.48232;
  long unsigned int D.48233;
  unsigned int D.48236;
  unsigned int D.48237;
  int D.48238;
  unsigned int D.48256;
  unsigned int D.48257;
  unsigned int D.48260;
  unsigned int D.48261;
  int D.48262;
  unsigned int D.48263;
  long int D.48264;
  struct MonoInst * D.48265;
  int D.48266;
  int D.48267;
  unsigned char * D.48271;
  long int D.48274;
  long int D.48275;
  long unsigned int D.48276;
  long unsigned int D.48277;
  struct MonoBasicBlock * * D.48278;
  long int D.48293;
  struct MonoInst * D.48294;
  int D.48295;
  int D.48296;
  struct MonoClass * D.48300;
  unsigned int D.48301;
  long int D.48302;
  struct MonoInst * D.48303;
  int D.48304;
  int D.48305;
  long int D.48309;
  struct MonoInst * D.48310;
  int D.48311;
  int D.48312;
  long int D.48316;
  struct MonoInst * D.48317;
  int D.48318;
  int D.48319;
  unsigned int D.48322;
  unsigned int D.48323;
  int D.48324;
  unsigned char * D.48328;
  long int D.48331;
  long int D.48332;
  long unsigned int D.48333;
  long unsigned int D.48334;
  struct MonoBasicBlock * * D.48335;
  void * D.48351;
  struct MonoBasicBlock * * D.48352;
  struct MonoBasicBlock * * D.48353;
  unsigned int D.48359;
  unsigned int D.48360;
  int D.48361;
  unsigned int D.48380;
  long int D.48381;
  struct MonoInst * D.48382;
  int D.48383;
  int D.48384;
  long int D.48388;
  struct MonoInst * D.48389;
  int D.48390;
  int D.48391;
  unsigned int D.48395;
  long int D.48396;
  struct MonoInst * D.48397;
  int D.48398;
  int D.48399;
  long int D.48403;
  struct MonoInst * D.48404;
  int D.48405;
  int D.48406;
  unsigned int D.48410;
  long int D.48411;
  struct MonoInst * D.48412;
  int D.48413;
  int D.48414;
  long int D.48418;
  struct MonoInst * D.48419;
  int D.48420;
  int D.48421;
  long int D.48425;
  struct MonoInst * D.48426;
  int D.48427;
  int D.48428;
  unsigned int D.48431;
  unsigned int D.48432;
  int D.48433;
  unsigned char * D.48437;
  long int D.48440;
  long int D.48441;
  long unsigned int D.48442;
  long unsigned int D.48443;
  struct MonoBasicBlock * * D.48444;
  void * D.48460;
  struct MonoBasicBlock * * D.48461;
  struct MonoBasicBlock * * D.48462;
  unsigned int D.48468;
  unsigned int D.48469;
  int D.48470;
  long int D.48488;
  struct MonoInst * D.48489;
  int D.48490;
  int D.48491;
  unsigned int D.48494;
  unsigned int D.48495;
  int D.48496;
  unsigned char * D.48500;
  long int D.48503;
  long int D.48504;
  long unsigned int D.48505;
  long unsigned int D.48506;
  struct MonoBasicBlock * * D.48507;
  void * D.48523;
  struct MonoBasicBlock * * D.48524;
  struct MonoBasicBlock * * D.48525;
  unsigned int D.48531;
  unsigned int D.48532;
  int D.48533;
  unsigned char * D.48551;
  long int D.48554;
  long int D.48555;
  long unsigned int D.48556;
  long unsigned int D.48557;
  struct MonoBasicBlock * * D.48558;
  unsigned char * D.48573;
  long int D.48576;
  long int D.48577;
  long unsigned int D.48578;
  long unsigned int D.48579;
  struct MonoBasicBlock * * D.48580;
  long int D.48595;
  struct MonoInst * D.48596;
  int D.48597;
  int D.48598;
  long int D.48602;
  struct MonoInst * D.48603;
  int D.48604;
  int D.48605;
  unsigned int D.48608;
  unsigned int D.48609;
  int D.48610;
  unsigned char * D.48614;
  long int D.48617;
  long int D.48618;
  long unsigned int D.48619;
  long unsigned int D.48620;
  struct MonoBasicBlock * * D.48621;
  void * D.48637;
  struct MonoBasicBlock * * D.48638;
  struct MonoBasicBlock * * D.48639;
  unsigned int D.48645;
  unsigned int D.48646;
  int D.48647;
  unsigned char * D.48665;
  long int D.48668;
  long int D.48669;
  long unsigned int D.48670;
  long unsigned int D.48671;
  struct MonoBasicBlock * * D.48672;
  long int D.48687;
  struct MonoInst * D.48688;
  int D.48689;
  int D.48690;
  long int D.48694;
  struct MonoInst * D.48695;
  int D.48696;
  int D.48697;
  unsigned int D.48700;
  unsigned int D.48701;
  int D.48702;
  unsigned char * D.48706;
  long int D.48709;
  long int D.48710;
  long unsigned int D.48711;
  long unsigned int D.48712;
  struct MonoBasicBlock * * D.48713;
  void * D.48729;
  struct MonoBasicBlock * * D.48730;
  struct MonoBasicBlock * * D.48731;
  unsigned int D.48737;
  unsigned int D.48738;
  int D.48739;
  unsigned char * D.48757;
  long int D.48760;
  long int D.48761;
  long unsigned int D.48762;
  long unsigned int D.48763;
  struct MonoBasicBlock * * D.48764;
  long int D.48779;
  struct MonoInst * D.48780;
  int D.48781;
  int D.48782;
  unsigned char * D.48786;
  long int D.48789;
  long int D.48790;
  long unsigned int D.48791;
  long unsigned int D.48792;
  struct MonoBasicBlock * * D.48793;
  long int D.48808;
  struct MonoInst * D.48809;
  int D.48810;
  int D.48811;
  struct MonoInst * D.48812;
  struct MonoInst * ins;
  struct MonoBasicBlock * true_bb;
  struct MonoBasicBlock * false_bb;
  struct MonoBasicBlock * false2_bb;
  struct MonoBasicBlock * end_bb;
  struct MonoBasicBlock * no_proxy_bb;
  struct MonoBasicBlock * interface_fail_bb;
  int obj_reg;
  int dreg;
  int tmp_reg;
  int klass_reg;

  obj_reg = src->dreg;
  D.48151 = alloc_ireg (cfg);
  dreg = (int) D.48151;
  D.48152 = alloc_preg (cfg);
  klass_reg = (int) D.48152;
  D.48153 = cfg->mempool;
  true_bb = mono_mempool_alloc0 (D.48153, 296);
  D.48154 = cfg->num_bblocks;
  D.48155 = D.48154;
  D.48156 = D.48155 + 1;
  cfg->num_bblocks = D.48156;
  D.48157 = (int) D.48155;
  true_bb->block_num = D.48157;
  D.48153 = cfg->mempool;
  false_bb = mono_mempool_alloc0 (D.48153, 296);
  D.48154 = cfg->num_bblocks;
  D.48158 = D.48154;
  D.48159 = D.48158 + 1;
  cfg->num_bblocks = D.48159;
  D.48160 = (int) D.48158;
  false_bb->block_num = D.48160;
  D.48153 = cfg->mempool;
  end_bb = mono_mempool_alloc0 (D.48153, 296);
  D.48154 = cfg->num_bblocks;
  D.48161 = D.48154;
  D.48162 = D.48161 + 1;
  cfg->num_bblocks = D.48162;
  D.48163 = (int) D.48161;
  end_bb->block_num = D.48163;
  D.48153 = cfg->mempool;
  false2_bb = mono_mempool_alloc0 (D.48153, 296);
  D.48154 = cfg->num_bblocks;
  D.48164 = D.48154;
  D.48165 = D.48164 + 1;
  cfg->num_bblocks = D.48165;
  D.48166 = (int) D.48164;
  false2_bb->block_num = D.48166;
  D.48153 = cfg->mempool;
  no_proxy_bb = mono_mempool_alloc0 (D.48153, 296);
  D.48154 = cfg->num_bblocks;
  D.48167 = D.48154;
  D.48168 = D.48167 + 1;
  cfg->num_bblocks = D.48168;
  D.48169 = (int) D.48167;
  no_proxy_bb->block_num = D.48169;
  {
    struct MonoInst * inst;

    D.48153 = cfg->mempool;
    inst = mono_mempool_alloc (D.48153, 80);
    inst->data.op[1].const_val = 0;
    D.48170 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48170;
    inst->prev = 0B;
    D.48171 = inst->prev;
    inst->next = D.48171;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48172 = inst->sreg3;
    inst->sreg2 = D.48172;
    D.48173 = inst->sreg2;
    inst->sreg1 = D.48173;
    D.48174 = cfg->ip;
    inst->cil_code = D.48174;
    inst->dreg = -1;
    inst->sreg1 = obj_reg;
    inst->data.op[1].const_val = 0;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48177>; else goto <D.48178>;
    <D.48177>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = inst;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    inst->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    goto <D.48179>;
    <D.48178>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48179>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.48153 = cfg->mempool;
    ins = mono_mempool_alloc (D.48153, 80);
    ins->data.op[1].const_val = 0;
    D.48180 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.48180;
    ins->prev = 0B;
    D.48181 = ins->prev;
    ins->next = D.48181;
    ins->opcode = 551;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.48182 = ins->sreg3;
    ins->sreg2 = D.48182;
    D.48183 = ins->sreg2;
    ins->sreg1 = D.48183;
    D.48174 = cfg->ip;
    ins->cil_code = D.48174;
    if (0 != 0) goto <D.48184>; else goto <D.48185>;
    <D.48184>:
    D.48153 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48153, 296);
    D.48154 = cfg->num_bblocks;
    D.48186 = D.48154;
    D.48187 = D.48186 + 1;
    cfg->num_bblocks = D.48187;
    D.48188 = (int) D.48186;
    falsebb->block_num = D.48188;
    ins->data.op[0].target_block = false_bb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, false_bb);
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48189>; else goto <D.48190>;
    <D.48189>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = ins;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    ins->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    goto <D.48191>;
    <D.48190>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48191>:
    D.48192 = falsebb->cil_code;
    if (D.48192 != 0B) goto <D.48193>; else goto <D.48194>;
    <D.48193>:
    D.48195 = cfg->cil_offset_to_bb;
    D.48192 = falsebb->cil_code;
    D.48196 = (long int) D.48192;
    D.48197 = cfg->cil_start;
    D.48198 = (long int) D.48197;
    D.48199 = D.48196 - D.48198;
    D.48200 = (long unsigned int) D.48199;
    D.48201 = D.48200 * 8;
    D.48202 = D.48195 + D.48201;
    *D.48202 = falsebb;
    <D.48194>:
    D.48203 = cfg->real_offset;
    falsebb->real_offset = D.48203;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48207>; else goto <D.48204>;
    <D.48207>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 <= 9) goto <D.48205>; else goto <D.48210>;
    <D.48210>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 <= 9) goto <D.48205>; else goto <D.48212>;
    <D.48212>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 <= 9) goto <D.48205>; else goto <D.48204>;
    <D.48205>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    D.48216 = *D.48215;
    if (D.48216 == 0B) goto <D.48217>; else goto <D.48204>;
    <D.48217>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    *D.48215 = falsebb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    goto <D.48206>;
    <D.48204>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 == 0B) goto <D.48218>; else goto <D.48220>;
    <D.48220>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 442) goto <D.48221>; else goto <D.48219>;
    <D.48221>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 759) goto <D.48222>; else goto <D.48219>;
    <D.48222>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 > 9) goto <D.48223>; else goto <D.48219>;
    <D.48223>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 > 9) goto <D.48224>; else goto <D.48219>;
    <D.48224>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 > 9) goto <D.48218>; else goto <D.48219>;
    <D.48218>:
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    <D.48219>:
    <D.48206>:
    D.48175 = cfg->cbb;
    D.48175->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.48225>;
    <D.48185>:
    D.48153 = cfg->mempool;
    D.48226 = mono_mempool_alloc (D.48153, 16);
    ins->data.op[1].many_blocks = D.48226;
    D.48227 = ins->data.op[1].many_blocks;
    *D.48227 = false_bb;
    D.48227 = ins->data.op[1].many_blocks;
    D.48228 = D.48227 + 8;
    *D.48228 = 0B;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, false_bb);
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48229>; else goto <D.48230>;
    <D.48229>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = ins;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    ins->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    goto <D.48231>;
    <D.48230>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48231>:
    D.48232 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.48233 = D.48232 & 268435456;
    if (D.48233 == 0) goto <D.48234>; else goto <D.48235>;
    <D.48234>:
    D.48153 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48153, 296);
    D.48154 = cfg->num_bblocks;
    D.48236 = D.48154;
    D.48237 = D.48236 + 1;
    cfg->num_bblocks = D.48237;
    D.48238 = (int) D.48236;
    falsebb->block_num = D.48238;
    D.48227 = ins->data.op[1].many_blocks;
    D.48228 = D.48227 + 8;
    *D.48228 = falsebb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    D.48192 = falsebb->cil_code;
    if (D.48192 != 0B) goto <D.48239>; else goto <D.48240>;
    <D.48239>:
    D.48195 = cfg->cil_offset_to_bb;
    D.48192 = falsebb->cil_code;
    D.48196 = (long int) D.48192;
    D.48197 = cfg->cil_start;
    D.48198 = (long int) D.48197;
    D.48199 = D.48196 - D.48198;
    D.48200 = (long unsigned int) D.48199;
    D.48201 = D.48200 * 8;
    D.48202 = D.48195 + D.48201;
    *D.48202 = falsebb;
    <D.48240>:
    D.48203 = cfg->real_offset;
    falsebb->real_offset = D.48203;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48244>; else goto <D.48241>;
    <D.48244>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 <= 9) goto <D.48242>; else goto <D.48245>;
    <D.48245>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 <= 9) goto <D.48242>; else goto <D.48246>;
    <D.48246>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 <= 9) goto <D.48242>; else goto <D.48241>;
    <D.48242>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    D.48216 = *D.48215;
    if (D.48216 == 0B) goto <D.48247>; else goto <D.48241>;
    <D.48247>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    *D.48215 = falsebb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    goto <D.48243>;
    <D.48241>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 == 0B) goto <D.48248>; else goto <D.48250>;
    <D.48250>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 442) goto <D.48251>; else goto <D.48249>;
    <D.48251>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 759) goto <D.48252>; else goto <D.48249>;
    <D.48252>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 > 9) goto <D.48253>; else goto <D.48249>;
    <D.48253>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 > 9) goto <D.48254>; else goto <D.48249>;
    <D.48254>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 > 9) goto <D.48248>; else goto <D.48249>;
    <D.48248>:
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    <D.48249>:
    <D.48243>:
    D.48175 = cfg->cbb;
    D.48175->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.48255>;
    <D.48235>:
    D.48175 = cfg->cbb;
    D.48175->extended = 1;
    <D.48255>:
    <D.48225>:
  }
  D.48256 = klass->flags;
  D.48257 = D.48256 & 32;
  if (D.48257 != 0) goto <D.48258>; else goto <D.48259>;
  <D.48258>:
  D.48153 = cfg->mempool;
  interface_fail_bb = mono_mempool_alloc0 (D.48153, 296);
  D.48154 = cfg->num_bblocks;
  D.48260 = D.48154;
  D.48261 = D.48260 + 1;
  cfg->num_bblocks = D.48261;
  D.48262 = (int) D.48260;
  interface_fail_bb->block_num = D.48262;
  D.48263 = alloc_preg (cfg);
  tmp_reg = (int) D.48263;
  {
    struct MonoInst * inst;

    D.48153 = cfg->mempool;
    inst = mono_mempool_alloc (D.48153, 80);
    inst->data.op[1].const_val = 0;
    D.48264 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48264;
    inst->prev = 0B;
    D.48265 = inst->prev;
    inst->next = D.48265;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48266 = inst->sreg3;
    inst->sreg2 = D.48266;
    D.48267 = inst->sreg2;
    inst->sreg1 = D.48267;
    D.48174 = cfg->ip;
    inst->cil_code = D.48174;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 0;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48268>; else goto <D.48269>;
    <D.48268>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = inst;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    inst->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    goto <D.48270>;
    <D.48269>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48270>:
  }
  mini_emit_iface_cast (cfg, tmp_reg, klass, interface_fail_bb, true_bb);
  D.48271 = interface_fail_bb->cil_code;
  if (D.48271 != 0B) goto <D.48272>; else goto <D.48273>;
  <D.48272>:
  D.48195 = cfg->cil_offset_to_bb;
  D.48271 = interface_fail_bb->cil_code;
  D.48274 = (long int) D.48271;
  D.48197 = cfg->cil_start;
  D.48198 = (long int) D.48197;
  D.48275 = D.48274 - D.48198;
  D.48276 = (long unsigned int) D.48275;
  D.48277 = D.48276 * 8;
  D.48278 = D.48195 + D.48277;
  *D.48278 = interface_fail_bb;
  <D.48273>:
  D.48203 = cfg->real_offset;
  interface_fail_bb->real_offset = D.48203;
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  if (D.48176 != 0B) goto <D.48282>; else goto <D.48279>;
  <D.48282>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48209 = D.48208 + 64985;
  if (D.48209 <= 9) goto <D.48280>; else goto <D.48283>;
  <D.48283>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48211 = D.48208 + 64878;
  if (D.48211 <= 9) goto <D.48280>; else goto <D.48284>;
  <D.48284>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48213 = D.48208 + 64888;
  if (D.48213 <= 9) goto <D.48280>; else goto <D.48279>;
  <D.48280>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48214 = D.48176->data.op[1].many_blocks;
  D.48215 = D.48214 + 8;
  D.48216 = *D.48215;
  if (D.48216 == 0B) goto <D.48285>; else goto <D.48279>;
  <D.48285>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48214 = D.48176->data.op[1].many_blocks;
  D.48215 = D.48214 + 8;
  *D.48215 = interface_fail_bb;
  D.48175 = cfg->cbb;
  mono_link_bblock (cfg, D.48175, interface_fail_bb);
  goto <D.48281>;
  <D.48279>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  if (D.48176 == 0B) goto <D.48286>; else goto <D.48288>;
  <D.48288>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  if (D.48208 != 442) goto <D.48289>; else goto <D.48287>;
  <D.48289>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  if (D.48208 != 759) goto <D.48290>; else goto <D.48287>;
  <D.48290>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48209 = D.48208 + 64985;
  if (D.48209 > 9) goto <D.48291>; else goto <D.48287>;
  <D.48291>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48211 = D.48208 + 64878;
  if (D.48211 > 9) goto <D.48292>; else goto <D.48287>;
  <D.48292>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48213 = D.48208 + 64888;
  if (D.48213 > 9) goto <D.48286>; else goto <D.48287>;
  <D.48286>:
  D.48175 = cfg->cbb;
  mono_link_bblock (cfg, D.48175, interface_fail_bb);
  <D.48287>:
  <D.48281>:
  D.48175 = cfg->cbb;
  D.48175->next_bb = interface_fail_bb;
  cfg->cbb = interface_fail_bb;
  {
    struct MonoInst * inst;

    D.48153 = cfg->mempool;
    inst = mono_mempool_alloc (D.48153, 80);
    inst->data.op[1].const_val = 0;
    D.48293 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48293;
    inst->prev = 0B;
    D.48294 = inst->prev;
    inst->next = D.48294;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48295 = inst->sreg3;
    inst->sreg2 = D.48295;
    D.48296 = inst->sreg2;
    inst->sreg1 = D.48296;
    D.48174 = cfg->ip;
    inst->cil_code = D.48174;
    inst->dreg = klass_reg;
    inst->sreg1 = tmp_reg;
    inst->data.op[0].const_val = 0;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48297>; else goto <D.48298>;
    <D.48297>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = inst;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    inst->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    goto <D.48299>;
    <D.48298>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48299>:
  }
  D.48300 = mono_defaults.transparent_proxy_class;
  mini_emit_class_check_branch (cfg, klass_reg, D.48300, 556, false_bb);
  D.48301 = alloc_preg (cfg);
  tmp_reg = (int) D.48301;
  {
    struct MonoInst * inst;

    D.48153 = cfg->mempool;
    inst = mono_mempool_alloc (D.48153, 80);
    inst->data.op[1].const_val = 0;
    D.48302 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48302;
    inst->prev = 0B;
    D.48303 = inst->prev;
    inst->next = D.48303;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48304 = inst->sreg3;
    inst->sreg2 = D.48304;
    D.48305 = inst->sreg2;
    inst->sreg1 = D.48305;
    D.48174 = cfg->ip;
    inst->cil_code = D.48174;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 32;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48306>; else goto <D.48307>;
    <D.48306>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = inst;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    inst->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    goto <D.48308>;
    <D.48307>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48308>:
  }
  {
    struct MonoInst * inst;

    D.48153 = cfg->mempool;
    inst = mono_mempool_alloc (D.48153, 80);
    inst->data.op[1].const_val = 0;
    D.48309 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48309;
    inst->prev = 0B;
    D.48310 = inst->prev;
    inst->next = D.48310;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48311 = inst->sreg3;
    inst->sreg2 = D.48311;
    D.48312 = inst->sreg2;
    inst->sreg1 = D.48312;
    D.48174 = cfg->ip;
    inst->cil_code = D.48174;
    inst->dreg = -1;
    inst->sreg1 = tmp_reg;
    inst->data.op[1].const_val = 0;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48313>; else goto <D.48314>;
    <D.48313>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = inst;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    inst->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    goto <D.48315>;
    <D.48314>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48315>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.48153 = cfg->mempool;
    ins = mono_mempool_alloc (D.48153, 80);
    ins->data.op[1].const_val = 0;
    D.48316 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.48316;
    ins->prev = 0B;
    D.48317 = ins->prev;
    ins->next = D.48317;
    ins->opcode = 556;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.48318 = ins->sreg3;
    ins->sreg2 = D.48318;
    D.48319 = ins->sreg2;
    ins->sreg1 = D.48319;
    D.48174 = cfg->ip;
    ins->cil_code = D.48174;
    if (0 != 0) goto <D.48320>; else goto <D.48321>;
    <D.48320>:
    D.48153 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48153, 296);
    D.48154 = cfg->num_bblocks;
    D.48322 = D.48154;
    D.48323 = D.48322 + 1;
    cfg->num_bblocks = D.48323;
    D.48324 = (int) D.48322;
    falsebb->block_num = D.48324;
    ins->data.op[0].target_block = false2_bb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, false2_bb);
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48325>; else goto <D.48326>;
    <D.48325>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = ins;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    ins->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    goto <D.48327>;
    <D.48326>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48327>:
    D.48328 = falsebb->cil_code;
    if (D.48328 != 0B) goto <D.48329>; else goto <D.48330>;
    <D.48329>:
    D.48195 = cfg->cil_offset_to_bb;
    D.48328 = falsebb->cil_code;
    D.48331 = (long int) D.48328;
    D.48197 = cfg->cil_start;
    D.48198 = (long int) D.48197;
    D.48332 = D.48331 - D.48198;
    D.48333 = (long unsigned int) D.48332;
    D.48334 = D.48333 * 8;
    D.48335 = D.48195 + D.48334;
    *D.48335 = falsebb;
    <D.48330>:
    D.48203 = cfg->real_offset;
    falsebb->real_offset = D.48203;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48339>; else goto <D.48336>;
    <D.48339>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 <= 9) goto <D.48337>; else goto <D.48340>;
    <D.48340>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 <= 9) goto <D.48337>; else goto <D.48341>;
    <D.48341>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 <= 9) goto <D.48337>; else goto <D.48336>;
    <D.48337>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    D.48216 = *D.48215;
    if (D.48216 == 0B) goto <D.48342>; else goto <D.48336>;
    <D.48342>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    *D.48215 = falsebb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    goto <D.48338>;
    <D.48336>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 == 0B) goto <D.48343>; else goto <D.48345>;
    <D.48345>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 442) goto <D.48346>; else goto <D.48344>;
    <D.48346>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 759) goto <D.48347>; else goto <D.48344>;
    <D.48347>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 > 9) goto <D.48348>; else goto <D.48344>;
    <D.48348>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 > 9) goto <D.48349>; else goto <D.48344>;
    <D.48349>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 > 9) goto <D.48343>; else goto <D.48344>;
    <D.48343>:
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    <D.48344>:
    <D.48338>:
    D.48175 = cfg->cbb;
    D.48175->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.48350>;
    <D.48321>:
    D.48153 = cfg->mempool;
    D.48351 = mono_mempool_alloc (D.48153, 16);
    ins->data.op[1].many_blocks = D.48351;
    D.48352 = ins->data.op[1].many_blocks;
    *D.48352 = false2_bb;
    D.48352 = ins->data.op[1].many_blocks;
    D.48353 = D.48352 + 8;
    *D.48353 = 0B;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, false2_bb);
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48354>; else goto <D.48355>;
    <D.48354>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = ins;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    ins->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    goto <D.48356>;
    <D.48355>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48356>:
    D.48232 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.48233 = D.48232 & 268435456;
    if (D.48233 == 0) goto <D.48357>; else goto <D.48358>;
    <D.48357>:
    D.48153 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48153, 296);
    D.48154 = cfg->num_bblocks;
    D.48359 = D.48154;
    D.48360 = D.48359 + 1;
    cfg->num_bblocks = D.48360;
    D.48361 = (int) D.48359;
    falsebb->block_num = D.48361;
    D.48352 = ins->data.op[1].many_blocks;
    D.48353 = D.48352 + 8;
    *D.48353 = falsebb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    D.48328 = falsebb->cil_code;
    if (D.48328 != 0B) goto <D.48362>; else goto <D.48363>;
    <D.48362>:
    D.48195 = cfg->cil_offset_to_bb;
    D.48328 = falsebb->cil_code;
    D.48331 = (long int) D.48328;
    D.48197 = cfg->cil_start;
    D.48198 = (long int) D.48197;
    D.48332 = D.48331 - D.48198;
    D.48333 = (long unsigned int) D.48332;
    D.48334 = D.48333 * 8;
    D.48335 = D.48195 + D.48334;
    *D.48335 = falsebb;
    <D.48363>:
    D.48203 = cfg->real_offset;
    falsebb->real_offset = D.48203;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48367>; else goto <D.48364>;
    <D.48367>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 <= 9) goto <D.48365>; else goto <D.48368>;
    <D.48368>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 <= 9) goto <D.48365>; else goto <D.48369>;
    <D.48369>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 <= 9) goto <D.48365>; else goto <D.48364>;
    <D.48365>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    D.48216 = *D.48215;
    if (D.48216 == 0B) goto <D.48370>; else goto <D.48364>;
    <D.48370>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    *D.48215 = falsebb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    goto <D.48366>;
    <D.48364>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 == 0B) goto <D.48371>; else goto <D.48373>;
    <D.48373>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 442) goto <D.48374>; else goto <D.48372>;
    <D.48374>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 759) goto <D.48375>; else goto <D.48372>;
    <D.48375>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 > 9) goto <D.48376>; else goto <D.48372>;
    <D.48376>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 > 9) goto <D.48377>; else goto <D.48372>;
    <D.48377>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 > 9) goto <D.48371>; else goto <D.48372>;
    <D.48371>:
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    <D.48372>:
    <D.48366>:
    D.48175 = cfg->cbb;
    D.48175->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.48378>;
    <D.48358>:
    D.48175 = cfg->cbb;
    D.48175->extended = 1;
    <D.48378>:
    <D.48350>:
  }
  goto <D.48379>;
  <D.48259>:
  D.48380 = alloc_preg (cfg);
  tmp_reg = (int) D.48380;
  {
    struct MonoInst * inst;

    D.48153 = cfg->mempool;
    inst = mono_mempool_alloc (D.48153, 80);
    inst->data.op[1].const_val = 0;
    D.48381 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48381;
    inst->prev = 0B;
    D.48382 = inst->prev;
    inst->next = D.48382;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48383 = inst->sreg3;
    inst->sreg2 = D.48383;
    D.48384 = inst->sreg2;
    inst->sreg1 = D.48384;
    D.48174 = cfg->ip;
    inst->cil_code = D.48174;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 0;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48385>; else goto <D.48386>;
    <D.48385>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = inst;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    inst->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    goto <D.48387>;
    <D.48386>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48387>:
  }
  {
    struct MonoInst * inst;

    D.48153 = cfg->mempool;
    inst = mono_mempool_alloc (D.48153, 80);
    inst->data.op[1].const_val = 0;
    D.48388 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48388;
    inst->prev = 0B;
    D.48389 = inst->prev;
    inst->next = D.48389;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48390 = inst->sreg3;
    inst->sreg2 = D.48390;
    D.48391 = inst->sreg2;
    inst->sreg1 = D.48391;
    D.48174 = cfg->ip;
    inst->cil_code = D.48174;
    inst->dreg = klass_reg;
    inst->sreg1 = tmp_reg;
    inst->data.op[0].const_val = 0;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48392>; else goto <D.48393>;
    <D.48392>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = inst;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    inst->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    goto <D.48394>;
    <D.48393>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48394>:
  }
  D.48300 = mono_defaults.transparent_proxy_class;
  mini_emit_class_check_branch (cfg, klass_reg, D.48300, 556, no_proxy_bb);
  D.48395 = alloc_preg (cfg);
  tmp_reg = (int) D.48395;
  {
    struct MonoInst * inst;

    D.48153 = cfg->mempool;
    inst = mono_mempool_alloc (D.48153, 80);
    inst->data.op[1].const_val = 0;
    D.48396 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48396;
    inst->prev = 0B;
    D.48397 = inst->prev;
    inst->next = D.48397;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48398 = inst->sreg3;
    inst->sreg2 = D.48398;
    D.48399 = inst->sreg2;
    inst->sreg1 = D.48399;
    D.48174 = cfg->ip;
    inst->cil_code = D.48174;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 24;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48400>; else goto <D.48401>;
    <D.48400>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = inst;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    inst->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    goto <D.48402>;
    <D.48401>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48402>:
  }
  {
    struct MonoInst * inst;

    D.48153 = cfg->mempool;
    inst = mono_mempool_alloc (D.48153, 80);
    inst->data.op[1].const_val = 0;
    D.48403 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48403;
    inst->prev = 0B;
    D.48404 = inst->prev;
    inst->next = D.48404;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48405 = inst->sreg3;
    inst->sreg2 = D.48405;
    D.48406 = inst->sreg2;
    inst->sreg1 = D.48406;
    D.48174 = cfg->ip;
    inst->cil_code = D.48174;
    inst->dreg = klass_reg;
    inst->sreg1 = tmp_reg;
    inst->data.op[0].const_val = 16;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48407>; else goto <D.48408>;
    <D.48407>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = inst;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    inst->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    goto <D.48409>;
    <D.48408>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48409>:
  }
  D.48410 = alloc_preg (cfg);
  tmp_reg = (int) D.48410;
  {
    struct MonoInst * inst;

    D.48153 = cfg->mempool;
    inst = mono_mempool_alloc (D.48153, 80);
    inst->data.op[1].const_val = 0;
    D.48411 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48411;
    inst->prev = 0B;
    D.48412 = inst->prev;
    inst->next = D.48412;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48413 = inst->sreg3;
    inst->sreg2 = D.48413;
    D.48414 = inst->sreg2;
    inst->sreg1 = D.48414;
    D.48174 = cfg->ip;
    inst->cil_code = D.48174;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 32;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48415>; else goto <D.48416>;
    <D.48415>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = inst;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    inst->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    goto <D.48417>;
    <D.48416>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48417>:
  }
  {
    struct MonoInst * inst;

    D.48153 = cfg->mempool;
    inst = mono_mempool_alloc (D.48153, 80);
    inst->data.op[1].const_val = 0;
    D.48418 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48418;
    inst->prev = 0B;
    D.48419 = inst->prev;
    inst->next = D.48419;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48420 = inst->sreg3;
    inst->sreg2 = D.48420;
    D.48421 = inst->sreg2;
    inst->sreg1 = D.48421;
    D.48174 = cfg->ip;
    inst->cil_code = D.48174;
    inst->dreg = -1;
    inst->sreg1 = tmp_reg;
    inst->data.op[1].const_val = 0;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48422>; else goto <D.48423>;
    <D.48422>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = inst;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    inst->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    goto <D.48424>;
    <D.48423>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48424>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.48153 = cfg->mempool;
    ins = mono_mempool_alloc (D.48153, 80);
    ins->data.op[1].const_val = 0;
    D.48425 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.48425;
    ins->prev = 0B;
    D.48426 = ins->prev;
    ins->next = D.48426;
    ins->opcode = 551;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.48427 = ins->sreg3;
    ins->sreg2 = D.48427;
    D.48428 = ins->sreg2;
    ins->sreg1 = D.48428;
    D.48174 = cfg->ip;
    ins->cil_code = D.48174;
    if (0 != 0) goto <D.48429>; else goto <D.48430>;
    <D.48429>:
    D.48153 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48153, 296);
    D.48154 = cfg->num_bblocks;
    D.48431 = D.48154;
    D.48432 = D.48431 + 1;
    cfg->num_bblocks = D.48432;
    D.48433 = (int) D.48431;
    falsebb->block_num = D.48433;
    ins->data.op[0].target_block = no_proxy_bb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, no_proxy_bb);
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48434>; else goto <D.48435>;
    <D.48434>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = ins;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    ins->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    goto <D.48436>;
    <D.48435>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48436>:
    D.48437 = falsebb->cil_code;
    if (D.48437 != 0B) goto <D.48438>; else goto <D.48439>;
    <D.48438>:
    D.48195 = cfg->cil_offset_to_bb;
    D.48437 = falsebb->cil_code;
    D.48440 = (long int) D.48437;
    D.48197 = cfg->cil_start;
    D.48198 = (long int) D.48197;
    D.48441 = D.48440 - D.48198;
    D.48442 = (long unsigned int) D.48441;
    D.48443 = D.48442 * 8;
    D.48444 = D.48195 + D.48443;
    *D.48444 = falsebb;
    <D.48439>:
    D.48203 = cfg->real_offset;
    falsebb->real_offset = D.48203;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48448>; else goto <D.48445>;
    <D.48448>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 <= 9) goto <D.48446>; else goto <D.48449>;
    <D.48449>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 <= 9) goto <D.48446>; else goto <D.48450>;
    <D.48450>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 <= 9) goto <D.48446>; else goto <D.48445>;
    <D.48446>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    D.48216 = *D.48215;
    if (D.48216 == 0B) goto <D.48451>; else goto <D.48445>;
    <D.48451>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    *D.48215 = falsebb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    goto <D.48447>;
    <D.48445>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 == 0B) goto <D.48452>; else goto <D.48454>;
    <D.48454>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 442) goto <D.48455>; else goto <D.48453>;
    <D.48455>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 759) goto <D.48456>; else goto <D.48453>;
    <D.48456>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 > 9) goto <D.48457>; else goto <D.48453>;
    <D.48457>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 > 9) goto <D.48458>; else goto <D.48453>;
    <D.48458>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 > 9) goto <D.48452>; else goto <D.48453>;
    <D.48452>:
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    <D.48453>:
    <D.48447>:
    D.48175 = cfg->cbb;
    D.48175->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.48459>;
    <D.48430>:
    D.48153 = cfg->mempool;
    D.48460 = mono_mempool_alloc (D.48153, 16);
    ins->data.op[1].many_blocks = D.48460;
    D.48461 = ins->data.op[1].many_blocks;
    *D.48461 = no_proxy_bb;
    D.48461 = ins->data.op[1].many_blocks;
    D.48462 = D.48461 + 8;
    *D.48462 = 0B;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, no_proxy_bb);
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48463>; else goto <D.48464>;
    <D.48463>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = ins;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    ins->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    goto <D.48465>;
    <D.48464>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48465>:
    D.48232 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.48233 = D.48232 & 268435456;
    if (D.48233 == 0) goto <D.48466>; else goto <D.48467>;
    <D.48466>:
    D.48153 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48153, 296);
    D.48154 = cfg->num_bblocks;
    D.48468 = D.48154;
    D.48469 = D.48468 + 1;
    cfg->num_bblocks = D.48469;
    D.48470 = (int) D.48468;
    falsebb->block_num = D.48470;
    D.48461 = ins->data.op[1].many_blocks;
    D.48462 = D.48461 + 8;
    *D.48462 = falsebb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    D.48437 = falsebb->cil_code;
    if (D.48437 != 0B) goto <D.48471>; else goto <D.48472>;
    <D.48471>:
    D.48195 = cfg->cil_offset_to_bb;
    D.48437 = falsebb->cil_code;
    D.48440 = (long int) D.48437;
    D.48197 = cfg->cil_start;
    D.48198 = (long int) D.48197;
    D.48441 = D.48440 - D.48198;
    D.48442 = (long unsigned int) D.48441;
    D.48443 = D.48442 * 8;
    D.48444 = D.48195 + D.48443;
    *D.48444 = falsebb;
    <D.48472>:
    D.48203 = cfg->real_offset;
    falsebb->real_offset = D.48203;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48476>; else goto <D.48473>;
    <D.48476>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 <= 9) goto <D.48474>; else goto <D.48477>;
    <D.48477>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 <= 9) goto <D.48474>; else goto <D.48478>;
    <D.48478>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 <= 9) goto <D.48474>; else goto <D.48473>;
    <D.48474>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    D.48216 = *D.48215;
    if (D.48216 == 0B) goto <D.48479>; else goto <D.48473>;
    <D.48479>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    *D.48215 = falsebb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    goto <D.48475>;
    <D.48473>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 == 0B) goto <D.48480>; else goto <D.48482>;
    <D.48482>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 442) goto <D.48483>; else goto <D.48481>;
    <D.48483>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 759) goto <D.48484>; else goto <D.48481>;
    <D.48484>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 > 9) goto <D.48485>; else goto <D.48481>;
    <D.48485>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 > 9) goto <D.48486>; else goto <D.48481>;
    <D.48486>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 > 9) goto <D.48480>; else goto <D.48481>;
    <D.48480>:
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    <D.48481>:
    <D.48475>:
    D.48175 = cfg->cbb;
    D.48175->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.48487>;
    <D.48467>:
    D.48175 = cfg->cbb;
    D.48175->extended = 1;
    <D.48487>:
    <D.48459>:
  }
  mini_emit_isninst_cast (cfg, klass_reg, klass, false2_bb, true_bb);
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.48153 = cfg->mempool;
    ins = mono_mempool_alloc (D.48153, 80);
    ins->data.op[1].const_val = 0;
    D.48488 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.48488;
    ins->prev = 0B;
    D.48489 = ins->prev;
    ins->next = D.48489;
    ins->opcode = 442;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.48490 = ins->sreg3;
    ins->sreg2 = D.48490;
    D.48491 = ins->sreg2;
    ins->sreg1 = D.48491;
    D.48174 = cfg->ip;
    ins->cil_code = D.48174;
    if (1 != 0) goto <D.48492>; else goto <D.48493>;
    <D.48492>:
    D.48153 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48153, 296);
    D.48154 = cfg->num_bblocks;
    D.48494 = D.48154;
    D.48495 = D.48494 + 1;
    cfg->num_bblocks = D.48495;
    D.48496 = (int) D.48494;
    falsebb->block_num = D.48496;
    ins->data.op[0].target_block = false2_bb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, false2_bb);
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48497>; else goto <D.48498>;
    <D.48497>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = ins;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    ins->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    goto <D.48499>;
    <D.48498>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48499>:
    D.48500 = falsebb->cil_code;
    if (D.48500 != 0B) goto <D.48501>; else goto <D.48502>;
    <D.48501>:
    D.48195 = cfg->cil_offset_to_bb;
    D.48500 = falsebb->cil_code;
    D.48503 = (long int) D.48500;
    D.48197 = cfg->cil_start;
    D.48198 = (long int) D.48197;
    D.48504 = D.48503 - D.48198;
    D.48505 = (long unsigned int) D.48504;
    D.48506 = D.48505 * 8;
    D.48507 = D.48195 + D.48506;
    *D.48507 = falsebb;
    <D.48502>:
    D.48203 = cfg->real_offset;
    falsebb->real_offset = D.48203;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48511>; else goto <D.48508>;
    <D.48511>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 <= 9) goto <D.48509>; else goto <D.48512>;
    <D.48512>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 <= 9) goto <D.48509>; else goto <D.48513>;
    <D.48513>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 <= 9) goto <D.48509>; else goto <D.48508>;
    <D.48509>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    D.48216 = *D.48215;
    if (D.48216 == 0B) goto <D.48514>; else goto <D.48508>;
    <D.48514>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    *D.48215 = falsebb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    goto <D.48510>;
    <D.48508>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 == 0B) goto <D.48515>; else goto <D.48517>;
    <D.48517>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 442) goto <D.48518>; else goto <D.48516>;
    <D.48518>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 759) goto <D.48519>; else goto <D.48516>;
    <D.48519>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 > 9) goto <D.48520>; else goto <D.48516>;
    <D.48520>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 > 9) goto <D.48521>; else goto <D.48516>;
    <D.48521>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 > 9) goto <D.48515>; else goto <D.48516>;
    <D.48515>:
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    <D.48516>:
    <D.48510>:
    D.48175 = cfg->cbb;
    D.48175->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.48522>;
    <D.48493>:
    D.48153 = cfg->mempool;
    D.48523 = mono_mempool_alloc (D.48153, 16);
    ins->data.op[1].many_blocks = D.48523;
    D.48524 = ins->data.op[1].many_blocks;
    *D.48524 = false2_bb;
    D.48524 = ins->data.op[1].many_blocks;
    D.48525 = D.48524 + 8;
    *D.48525 = 0B;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, false2_bb);
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48526>; else goto <D.48527>;
    <D.48526>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = ins;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    ins->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    goto <D.48528>;
    <D.48527>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48528>:
    D.48232 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.48233 = D.48232 & 268435456;
    if (D.48233 == 0) goto <D.48529>; else goto <D.48530>;
    <D.48529>:
    D.48153 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48153, 296);
    D.48154 = cfg->num_bblocks;
    D.48531 = D.48154;
    D.48532 = D.48531 + 1;
    cfg->num_bblocks = D.48532;
    D.48533 = (int) D.48531;
    falsebb->block_num = D.48533;
    D.48524 = ins->data.op[1].many_blocks;
    D.48525 = D.48524 + 8;
    *D.48525 = falsebb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    D.48500 = falsebb->cil_code;
    if (D.48500 != 0B) goto <D.48534>; else goto <D.48535>;
    <D.48534>:
    D.48195 = cfg->cil_offset_to_bb;
    D.48500 = falsebb->cil_code;
    D.48503 = (long int) D.48500;
    D.48197 = cfg->cil_start;
    D.48198 = (long int) D.48197;
    D.48504 = D.48503 - D.48198;
    D.48505 = (long unsigned int) D.48504;
    D.48506 = D.48505 * 8;
    D.48507 = D.48195 + D.48506;
    *D.48507 = falsebb;
    <D.48535>:
    D.48203 = cfg->real_offset;
    falsebb->real_offset = D.48203;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48539>; else goto <D.48536>;
    <D.48539>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 <= 9) goto <D.48537>; else goto <D.48540>;
    <D.48540>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 <= 9) goto <D.48537>; else goto <D.48541>;
    <D.48541>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 <= 9) goto <D.48537>; else goto <D.48536>;
    <D.48537>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    D.48216 = *D.48215;
    if (D.48216 == 0B) goto <D.48542>; else goto <D.48536>;
    <D.48542>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    *D.48215 = falsebb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    goto <D.48538>;
    <D.48536>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 == 0B) goto <D.48543>; else goto <D.48545>;
    <D.48545>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 442) goto <D.48546>; else goto <D.48544>;
    <D.48546>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 759) goto <D.48547>; else goto <D.48544>;
    <D.48547>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 > 9) goto <D.48548>; else goto <D.48544>;
    <D.48548>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 > 9) goto <D.48549>; else goto <D.48544>;
    <D.48549>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 > 9) goto <D.48543>; else goto <D.48544>;
    <D.48543>:
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    <D.48544>:
    <D.48538>:
    D.48175 = cfg->cbb;
    D.48175->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.48550>;
    <D.48530>:
    D.48175 = cfg->cbb;
    D.48175->extended = 1;
    <D.48550>:
    <D.48522>:
  }
  D.48551 = no_proxy_bb->cil_code;
  if (D.48551 != 0B) goto <D.48552>; else goto <D.48553>;
  <D.48552>:
  D.48195 = cfg->cil_offset_to_bb;
  D.48551 = no_proxy_bb->cil_code;
  D.48554 = (long int) D.48551;
  D.48197 = cfg->cil_start;
  D.48198 = (long int) D.48197;
  D.48555 = D.48554 - D.48198;
  D.48556 = (long unsigned int) D.48555;
  D.48557 = D.48556 * 8;
  D.48558 = D.48195 + D.48557;
  *D.48558 = no_proxy_bb;
  <D.48553>:
  D.48203 = cfg->real_offset;
  no_proxy_bb->real_offset = D.48203;
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  if (D.48176 != 0B) goto <D.48562>; else goto <D.48559>;
  <D.48562>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48209 = D.48208 + 64985;
  if (D.48209 <= 9) goto <D.48560>; else goto <D.48563>;
  <D.48563>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48211 = D.48208 + 64878;
  if (D.48211 <= 9) goto <D.48560>; else goto <D.48564>;
  <D.48564>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48213 = D.48208 + 64888;
  if (D.48213 <= 9) goto <D.48560>; else goto <D.48559>;
  <D.48560>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48214 = D.48176->data.op[1].many_blocks;
  D.48215 = D.48214 + 8;
  D.48216 = *D.48215;
  if (D.48216 == 0B) goto <D.48565>; else goto <D.48559>;
  <D.48565>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48214 = D.48176->data.op[1].many_blocks;
  D.48215 = D.48214 + 8;
  *D.48215 = no_proxy_bb;
  D.48175 = cfg->cbb;
  mono_link_bblock (cfg, D.48175, no_proxy_bb);
  goto <D.48561>;
  <D.48559>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  if (D.48176 == 0B) goto <D.48566>; else goto <D.48568>;
  <D.48568>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  if (D.48208 != 442) goto <D.48569>; else goto <D.48567>;
  <D.48569>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  if (D.48208 != 759) goto <D.48570>; else goto <D.48567>;
  <D.48570>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48209 = D.48208 + 64985;
  if (D.48209 > 9) goto <D.48571>; else goto <D.48567>;
  <D.48571>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48211 = D.48208 + 64878;
  if (D.48211 > 9) goto <D.48572>; else goto <D.48567>;
  <D.48572>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48213 = D.48208 + 64888;
  if (D.48213 > 9) goto <D.48566>; else goto <D.48567>;
  <D.48566>:
  D.48175 = cfg->cbb;
  mono_link_bblock (cfg, D.48175, no_proxy_bb);
  <D.48567>:
  <D.48561>:
  D.48175 = cfg->cbb;
  D.48175->next_bb = no_proxy_bb;
  cfg->cbb = no_proxy_bb;
  mini_emit_isninst_cast (cfg, klass_reg, klass, false_bb, true_bb);
  <D.48379>:
  D.48573 = false_bb->cil_code;
  if (D.48573 != 0B) goto <D.48574>; else goto <D.48575>;
  <D.48574>:
  D.48195 = cfg->cil_offset_to_bb;
  D.48573 = false_bb->cil_code;
  D.48576 = (long int) D.48573;
  D.48197 = cfg->cil_start;
  D.48198 = (long int) D.48197;
  D.48577 = D.48576 - D.48198;
  D.48578 = (long unsigned int) D.48577;
  D.48579 = D.48578 * 8;
  D.48580 = D.48195 + D.48579;
  *D.48580 = false_bb;
  <D.48575>:
  D.48203 = cfg->real_offset;
  false_bb->real_offset = D.48203;
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  if (D.48176 != 0B) goto <D.48584>; else goto <D.48581>;
  <D.48584>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48209 = D.48208 + 64985;
  if (D.48209 <= 9) goto <D.48582>; else goto <D.48585>;
  <D.48585>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48211 = D.48208 + 64878;
  if (D.48211 <= 9) goto <D.48582>; else goto <D.48586>;
  <D.48586>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48213 = D.48208 + 64888;
  if (D.48213 <= 9) goto <D.48582>; else goto <D.48581>;
  <D.48582>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48214 = D.48176->data.op[1].many_blocks;
  D.48215 = D.48214 + 8;
  D.48216 = *D.48215;
  if (D.48216 == 0B) goto <D.48587>; else goto <D.48581>;
  <D.48587>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48214 = D.48176->data.op[1].many_blocks;
  D.48215 = D.48214 + 8;
  *D.48215 = false_bb;
  D.48175 = cfg->cbb;
  mono_link_bblock (cfg, D.48175, false_bb);
  goto <D.48583>;
  <D.48581>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  if (D.48176 == 0B) goto <D.48588>; else goto <D.48590>;
  <D.48590>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  if (D.48208 != 442) goto <D.48591>; else goto <D.48589>;
  <D.48591>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  if (D.48208 != 759) goto <D.48592>; else goto <D.48589>;
  <D.48592>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48209 = D.48208 + 64985;
  if (D.48209 > 9) goto <D.48593>; else goto <D.48589>;
  <D.48593>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48211 = D.48208 + 64878;
  if (D.48211 > 9) goto <D.48594>; else goto <D.48589>;
  <D.48594>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48213 = D.48208 + 64888;
  if (D.48213 > 9) goto <D.48588>; else goto <D.48589>;
  <D.48588>:
  D.48175 = cfg->cbb;
  mono_link_bblock (cfg, D.48175, false_bb);
  <D.48589>:
  <D.48583>:
  D.48175 = cfg->cbb;
  D.48175->next_bb = false_bb;
  cfg->cbb = false_bb;
  {
    struct MonoInst * inst;

    D.48153 = cfg->mempool;
    inst = mono_mempool_alloc (D.48153, 80);
    inst->data.op[1].const_val = 0;
    D.48595 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48595;
    inst->prev = 0B;
    D.48596 = inst->prev;
    inst->next = D.48596;
    inst->opcode = 362;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48597 = inst->sreg3;
    inst->sreg2 = D.48597;
    D.48598 = inst->sreg2;
    inst->sreg1 = D.48598;
    D.48174 = cfg->ip;
    inst->cil_code = D.48174;
    inst->dreg = dreg;
    inst->data.op[0].const_val = 1;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48599>; else goto <D.48600>;
    <D.48599>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = inst;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    inst->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    goto <D.48601>;
    <D.48600>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48601>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.48153 = cfg->mempool;
    ins = mono_mempool_alloc (D.48153, 80);
    ins->data.op[1].const_val = 0;
    D.48602 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.48602;
    ins->prev = 0B;
    D.48603 = ins->prev;
    ins->next = D.48603;
    ins->opcode = 442;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.48604 = ins->sreg3;
    ins->sreg2 = D.48604;
    D.48605 = ins->sreg2;
    ins->sreg1 = D.48605;
    D.48174 = cfg->ip;
    ins->cil_code = D.48174;
    if (1 != 0) goto <D.48606>; else goto <D.48607>;
    <D.48606>:
    D.48153 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48153, 296);
    D.48154 = cfg->num_bblocks;
    D.48608 = D.48154;
    D.48609 = D.48608 + 1;
    cfg->num_bblocks = D.48609;
    D.48610 = (int) D.48608;
    falsebb->block_num = D.48610;
    ins->data.op[0].target_block = end_bb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, end_bb);
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48611>; else goto <D.48612>;
    <D.48611>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = ins;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    ins->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    goto <D.48613>;
    <D.48612>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48613>:
    D.48614 = falsebb->cil_code;
    if (D.48614 != 0B) goto <D.48615>; else goto <D.48616>;
    <D.48615>:
    D.48195 = cfg->cil_offset_to_bb;
    D.48614 = falsebb->cil_code;
    D.48617 = (long int) D.48614;
    D.48197 = cfg->cil_start;
    D.48198 = (long int) D.48197;
    D.48618 = D.48617 - D.48198;
    D.48619 = (long unsigned int) D.48618;
    D.48620 = D.48619 * 8;
    D.48621 = D.48195 + D.48620;
    *D.48621 = falsebb;
    <D.48616>:
    D.48203 = cfg->real_offset;
    falsebb->real_offset = D.48203;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48625>; else goto <D.48622>;
    <D.48625>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 <= 9) goto <D.48623>; else goto <D.48626>;
    <D.48626>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 <= 9) goto <D.48623>; else goto <D.48627>;
    <D.48627>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 <= 9) goto <D.48623>; else goto <D.48622>;
    <D.48623>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    D.48216 = *D.48215;
    if (D.48216 == 0B) goto <D.48628>; else goto <D.48622>;
    <D.48628>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    *D.48215 = falsebb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    goto <D.48624>;
    <D.48622>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 == 0B) goto <D.48629>; else goto <D.48631>;
    <D.48631>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 442) goto <D.48632>; else goto <D.48630>;
    <D.48632>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 759) goto <D.48633>; else goto <D.48630>;
    <D.48633>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 > 9) goto <D.48634>; else goto <D.48630>;
    <D.48634>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 > 9) goto <D.48635>; else goto <D.48630>;
    <D.48635>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 > 9) goto <D.48629>; else goto <D.48630>;
    <D.48629>:
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    <D.48630>:
    <D.48624>:
    D.48175 = cfg->cbb;
    D.48175->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.48636>;
    <D.48607>:
    D.48153 = cfg->mempool;
    D.48637 = mono_mempool_alloc (D.48153, 16);
    ins->data.op[1].many_blocks = D.48637;
    D.48638 = ins->data.op[1].many_blocks;
    *D.48638 = end_bb;
    D.48638 = ins->data.op[1].many_blocks;
    D.48639 = D.48638 + 8;
    *D.48639 = 0B;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, end_bb);
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48640>; else goto <D.48641>;
    <D.48640>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = ins;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    ins->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    goto <D.48642>;
    <D.48641>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48642>:
    D.48232 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.48233 = D.48232 & 268435456;
    if (D.48233 == 0) goto <D.48643>; else goto <D.48644>;
    <D.48643>:
    D.48153 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48153, 296);
    D.48154 = cfg->num_bblocks;
    D.48645 = D.48154;
    D.48646 = D.48645 + 1;
    cfg->num_bblocks = D.48646;
    D.48647 = (int) D.48645;
    falsebb->block_num = D.48647;
    D.48638 = ins->data.op[1].many_blocks;
    D.48639 = D.48638 + 8;
    *D.48639 = falsebb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    D.48614 = falsebb->cil_code;
    if (D.48614 != 0B) goto <D.48648>; else goto <D.48649>;
    <D.48648>:
    D.48195 = cfg->cil_offset_to_bb;
    D.48614 = falsebb->cil_code;
    D.48617 = (long int) D.48614;
    D.48197 = cfg->cil_start;
    D.48198 = (long int) D.48197;
    D.48618 = D.48617 - D.48198;
    D.48619 = (long unsigned int) D.48618;
    D.48620 = D.48619 * 8;
    D.48621 = D.48195 + D.48620;
    *D.48621 = falsebb;
    <D.48649>:
    D.48203 = cfg->real_offset;
    falsebb->real_offset = D.48203;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48653>; else goto <D.48650>;
    <D.48653>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 <= 9) goto <D.48651>; else goto <D.48654>;
    <D.48654>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 <= 9) goto <D.48651>; else goto <D.48655>;
    <D.48655>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 <= 9) goto <D.48651>; else goto <D.48650>;
    <D.48651>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    D.48216 = *D.48215;
    if (D.48216 == 0B) goto <D.48656>; else goto <D.48650>;
    <D.48656>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    *D.48215 = falsebb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    goto <D.48652>;
    <D.48650>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 == 0B) goto <D.48657>; else goto <D.48659>;
    <D.48659>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 442) goto <D.48660>; else goto <D.48658>;
    <D.48660>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 759) goto <D.48661>; else goto <D.48658>;
    <D.48661>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 > 9) goto <D.48662>; else goto <D.48658>;
    <D.48662>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 > 9) goto <D.48663>; else goto <D.48658>;
    <D.48663>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 > 9) goto <D.48657>; else goto <D.48658>;
    <D.48657>:
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    <D.48658>:
    <D.48652>:
    D.48175 = cfg->cbb;
    D.48175->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.48664>;
    <D.48644>:
    D.48175 = cfg->cbb;
    D.48175->extended = 1;
    <D.48664>:
    <D.48636>:
  }
  D.48665 = false2_bb->cil_code;
  if (D.48665 != 0B) goto <D.48666>; else goto <D.48667>;
  <D.48666>:
  D.48195 = cfg->cil_offset_to_bb;
  D.48665 = false2_bb->cil_code;
  D.48668 = (long int) D.48665;
  D.48197 = cfg->cil_start;
  D.48198 = (long int) D.48197;
  D.48669 = D.48668 - D.48198;
  D.48670 = (long unsigned int) D.48669;
  D.48671 = D.48670 * 8;
  D.48672 = D.48195 + D.48671;
  *D.48672 = false2_bb;
  <D.48667>:
  D.48203 = cfg->real_offset;
  false2_bb->real_offset = D.48203;
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  if (D.48176 != 0B) goto <D.48676>; else goto <D.48673>;
  <D.48676>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48209 = D.48208 + 64985;
  if (D.48209 <= 9) goto <D.48674>; else goto <D.48677>;
  <D.48677>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48211 = D.48208 + 64878;
  if (D.48211 <= 9) goto <D.48674>; else goto <D.48678>;
  <D.48678>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48213 = D.48208 + 64888;
  if (D.48213 <= 9) goto <D.48674>; else goto <D.48673>;
  <D.48674>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48214 = D.48176->data.op[1].many_blocks;
  D.48215 = D.48214 + 8;
  D.48216 = *D.48215;
  if (D.48216 == 0B) goto <D.48679>; else goto <D.48673>;
  <D.48679>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48214 = D.48176->data.op[1].many_blocks;
  D.48215 = D.48214 + 8;
  *D.48215 = false2_bb;
  D.48175 = cfg->cbb;
  mono_link_bblock (cfg, D.48175, false2_bb);
  goto <D.48675>;
  <D.48673>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  if (D.48176 == 0B) goto <D.48680>; else goto <D.48682>;
  <D.48682>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  if (D.48208 != 442) goto <D.48683>; else goto <D.48681>;
  <D.48683>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  if (D.48208 != 759) goto <D.48684>; else goto <D.48681>;
  <D.48684>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48209 = D.48208 + 64985;
  if (D.48209 > 9) goto <D.48685>; else goto <D.48681>;
  <D.48685>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48211 = D.48208 + 64878;
  if (D.48211 > 9) goto <D.48686>; else goto <D.48681>;
  <D.48686>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48213 = D.48208 + 64888;
  if (D.48213 > 9) goto <D.48680>; else goto <D.48681>;
  <D.48680>:
  D.48175 = cfg->cbb;
  mono_link_bblock (cfg, D.48175, false2_bb);
  <D.48681>:
  <D.48675>:
  D.48175 = cfg->cbb;
  D.48175->next_bb = false2_bb;
  cfg->cbb = false2_bb;
  {
    struct MonoInst * inst;

    D.48153 = cfg->mempool;
    inst = mono_mempool_alloc (D.48153, 80);
    inst->data.op[1].const_val = 0;
    D.48687 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48687;
    inst->prev = 0B;
    D.48688 = inst->prev;
    inst->next = D.48688;
    inst->opcode = 362;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48689 = inst->sreg3;
    inst->sreg2 = D.48689;
    D.48690 = inst->sreg2;
    inst->sreg1 = D.48690;
    D.48174 = cfg->ip;
    inst->cil_code = D.48174;
    inst->dreg = dreg;
    inst->data.op[0].const_val = 2;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48691>; else goto <D.48692>;
    <D.48691>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = inst;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    inst->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    goto <D.48693>;
    <D.48692>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48693>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.48153 = cfg->mempool;
    ins = mono_mempool_alloc (D.48153, 80);
    ins->data.op[1].const_val = 0;
    D.48694 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.48694;
    ins->prev = 0B;
    D.48695 = ins->prev;
    ins->next = D.48695;
    ins->opcode = 442;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.48696 = ins->sreg3;
    ins->sreg2 = D.48696;
    D.48697 = ins->sreg2;
    ins->sreg1 = D.48697;
    D.48174 = cfg->ip;
    ins->cil_code = D.48174;
    if (1 != 0) goto <D.48698>; else goto <D.48699>;
    <D.48698>:
    D.48153 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48153, 296);
    D.48154 = cfg->num_bblocks;
    D.48700 = D.48154;
    D.48701 = D.48700 + 1;
    cfg->num_bblocks = D.48701;
    D.48702 = (int) D.48700;
    falsebb->block_num = D.48702;
    ins->data.op[0].target_block = end_bb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, end_bb);
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48703>; else goto <D.48704>;
    <D.48703>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = ins;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    ins->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    goto <D.48705>;
    <D.48704>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48705>:
    D.48706 = falsebb->cil_code;
    if (D.48706 != 0B) goto <D.48707>; else goto <D.48708>;
    <D.48707>:
    D.48195 = cfg->cil_offset_to_bb;
    D.48706 = falsebb->cil_code;
    D.48709 = (long int) D.48706;
    D.48197 = cfg->cil_start;
    D.48198 = (long int) D.48197;
    D.48710 = D.48709 - D.48198;
    D.48711 = (long unsigned int) D.48710;
    D.48712 = D.48711 * 8;
    D.48713 = D.48195 + D.48712;
    *D.48713 = falsebb;
    <D.48708>:
    D.48203 = cfg->real_offset;
    falsebb->real_offset = D.48203;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48717>; else goto <D.48714>;
    <D.48717>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 <= 9) goto <D.48715>; else goto <D.48718>;
    <D.48718>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 <= 9) goto <D.48715>; else goto <D.48719>;
    <D.48719>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 <= 9) goto <D.48715>; else goto <D.48714>;
    <D.48715>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    D.48216 = *D.48215;
    if (D.48216 == 0B) goto <D.48720>; else goto <D.48714>;
    <D.48720>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    *D.48215 = falsebb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    goto <D.48716>;
    <D.48714>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 == 0B) goto <D.48721>; else goto <D.48723>;
    <D.48723>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 442) goto <D.48724>; else goto <D.48722>;
    <D.48724>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 759) goto <D.48725>; else goto <D.48722>;
    <D.48725>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 > 9) goto <D.48726>; else goto <D.48722>;
    <D.48726>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 > 9) goto <D.48727>; else goto <D.48722>;
    <D.48727>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 > 9) goto <D.48721>; else goto <D.48722>;
    <D.48721>:
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    <D.48722>:
    <D.48716>:
    D.48175 = cfg->cbb;
    D.48175->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.48728>;
    <D.48699>:
    D.48153 = cfg->mempool;
    D.48729 = mono_mempool_alloc (D.48153, 16);
    ins->data.op[1].many_blocks = D.48729;
    D.48730 = ins->data.op[1].many_blocks;
    *D.48730 = end_bb;
    D.48730 = ins->data.op[1].many_blocks;
    D.48731 = D.48730 + 8;
    *D.48731 = 0B;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, end_bb);
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48732>; else goto <D.48733>;
    <D.48732>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = ins;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    ins->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    goto <D.48734>;
    <D.48733>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = ins;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48734>:
    D.48232 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.48233 = D.48232 & 268435456;
    if (D.48233 == 0) goto <D.48735>; else goto <D.48736>;
    <D.48735>:
    D.48153 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48153, 296);
    D.48154 = cfg->num_bblocks;
    D.48737 = D.48154;
    D.48738 = D.48737 + 1;
    cfg->num_bblocks = D.48738;
    D.48739 = (int) D.48737;
    falsebb->block_num = D.48739;
    D.48730 = ins->data.op[1].many_blocks;
    D.48731 = D.48730 + 8;
    *D.48731 = falsebb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    D.48706 = falsebb->cil_code;
    if (D.48706 != 0B) goto <D.48740>; else goto <D.48741>;
    <D.48740>:
    D.48195 = cfg->cil_offset_to_bb;
    D.48706 = falsebb->cil_code;
    D.48709 = (long int) D.48706;
    D.48197 = cfg->cil_start;
    D.48198 = (long int) D.48197;
    D.48710 = D.48709 - D.48198;
    D.48711 = (long unsigned int) D.48710;
    D.48712 = D.48711 * 8;
    D.48713 = D.48195 + D.48712;
    *D.48713 = falsebb;
    <D.48741>:
    D.48203 = cfg->real_offset;
    falsebb->real_offset = D.48203;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48745>; else goto <D.48742>;
    <D.48745>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 <= 9) goto <D.48743>; else goto <D.48746>;
    <D.48746>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 <= 9) goto <D.48743>; else goto <D.48747>;
    <D.48747>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 <= 9) goto <D.48743>; else goto <D.48742>;
    <D.48743>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    D.48216 = *D.48215;
    if (D.48216 == 0B) goto <D.48748>; else goto <D.48742>;
    <D.48748>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48214 = D.48176->data.op[1].many_blocks;
    D.48215 = D.48214 + 8;
    *D.48215 = falsebb;
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    goto <D.48744>;
    <D.48742>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 == 0B) goto <D.48749>; else goto <D.48751>;
    <D.48751>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 442) goto <D.48752>; else goto <D.48750>;
    <D.48752>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    if (D.48208 != 759) goto <D.48753>; else goto <D.48750>;
    <D.48753>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48209 = D.48208 + 64985;
    if (D.48209 > 9) goto <D.48754>; else goto <D.48750>;
    <D.48754>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48211 = D.48208 + 64878;
    if (D.48211 > 9) goto <D.48755>; else goto <D.48750>;
    <D.48755>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48208 = D.48176->opcode;
    D.48213 = D.48208 + 64888;
    if (D.48213 > 9) goto <D.48749>; else goto <D.48750>;
    <D.48749>:
    D.48175 = cfg->cbb;
    mono_link_bblock (cfg, D.48175, falsebb);
    <D.48750>:
    <D.48744>:
    D.48175 = cfg->cbb;
    D.48175->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.48756>;
    <D.48736>:
    D.48175 = cfg->cbb;
    D.48175->extended = 1;
    <D.48756>:
    <D.48728>:
  }
  D.48757 = true_bb->cil_code;
  if (D.48757 != 0B) goto <D.48758>; else goto <D.48759>;
  <D.48758>:
  D.48195 = cfg->cil_offset_to_bb;
  D.48757 = true_bb->cil_code;
  D.48760 = (long int) D.48757;
  D.48197 = cfg->cil_start;
  D.48198 = (long int) D.48197;
  D.48761 = D.48760 - D.48198;
  D.48762 = (long unsigned int) D.48761;
  D.48763 = D.48762 * 8;
  D.48764 = D.48195 + D.48763;
  *D.48764 = true_bb;
  <D.48759>:
  D.48203 = cfg->real_offset;
  true_bb->real_offset = D.48203;
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  if (D.48176 != 0B) goto <D.48768>; else goto <D.48765>;
  <D.48768>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48209 = D.48208 + 64985;
  if (D.48209 <= 9) goto <D.48766>; else goto <D.48769>;
  <D.48769>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48211 = D.48208 + 64878;
  if (D.48211 <= 9) goto <D.48766>; else goto <D.48770>;
  <D.48770>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48213 = D.48208 + 64888;
  if (D.48213 <= 9) goto <D.48766>; else goto <D.48765>;
  <D.48766>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48214 = D.48176->data.op[1].many_blocks;
  D.48215 = D.48214 + 8;
  D.48216 = *D.48215;
  if (D.48216 == 0B) goto <D.48771>; else goto <D.48765>;
  <D.48771>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48214 = D.48176->data.op[1].many_blocks;
  D.48215 = D.48214 + 8;
  *D.48215 = true_bb;
  D.48175 = cfg->cbb;
  mono_link_bblock (cfg, D.48175, true_bb);
  goto <D.48767>;
  <D.48765>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  if (D.48176 == 0B) goto <D.48772>; else goto <D.48774>;
  <D.48774>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  if (D.48208 != 442) goto <D.48775>; else goto <D.48773>;
  <D.48775>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  if (D.48208 != 759) goto <D.48776>; else goto <D.48773>;
  <D.48776>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48209 = D.48208 + 64985;
  if (D.48209 > 9) goto <D.48777>; else goto <D.48773>;
  <D.48777>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48211 = D.48208 + 64878;
  if (D.48211 > 9) goto <D.48778>; else goto <D.48773>;
  <D.48778>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48213 = D.48208 + 64888;
  if (D.48213 > 9) goto <D.48772>; else goto <D.48773>;
  <D.48772>:
  D.48175 = cfg->cbb;
  mono_link_bblock (cfg, D.48175, true_bb);
  <D.48773>:
  <D.48767>:
  D.48175 = cfg->cbb;
  D.48175->next_bb = true_bb;
  cfg->cbb = true_bb;
  {
    struct MonoInst * inst;

    D.48153 = cfg->mempool;
    inst = mono_mempool_alloc (D.48153, 80);
    inst->data.op[1].const_val = 0;
    D.48779 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48779;
    inst->prev = 0B;
    D.48780 = inst->prev;
    inst->next = D.48780;
    inst->opcode = 362;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48781 = inst->sreg3;
    inst->sreg2 = D.48781;
    D.48782 = inst->sreg2;
    inst->sreg1 = D.48782;
    D.48174 = cfg->ip;
    inst->cil_code = D.48174;
    inst->dreg = dreg;
    inst->data.op[0].const_val = 0;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    if (D.48176 != 0B) goto <D.48783>; else goto <D.48784>;
    <D.48783>:
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    D.48176->next = inst;
    D.48175 = cfg->cbb;
    D.48176 = D.48175->last_ins;
    inst->prev = D.48176;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    goto <D.48785>;
    <D.48784>:
    D.48175 = cfg->cbb;
    D.48175 = cfg->cbb;
    D.48175->last_ins = inst;
    D.48176 = D.48175->last_ins;
    D.48175->code = D.48176;
    <D.48785>:
  }
  D.48786 = end_bb->cil_code;
  if (D.48786 != 0B) goto <D.48787>; else goto <D.48788>;
  <D.48787>:
  D.48195 = cfg->cil_offset_to_bb;
  D.48786 = end_bb->cil_code;
  D.48789 = (long int) D.48786;
  D.48197 = cfg->cil_start;
  D.48198 = (long int) D.48197;
  D.48790 = D.48789 - D.48198;
  D.48791 = (long unsigned int) D.48790;
  D.48792 = D.48791 * 8;
  D.48793 = D.48195 + D.48792;
  *D.48793 = end_bb;
  <D.48788>:
  D.48203 = cfg->real_offset;
  end_bb->real_offset = D.48203;
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  if (D.48176 != 0B) goto <D.48797>; else goto <D.48794>;
  <D.48797>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48209 = D.48208 + 64985;
  if (D.48209 <= 9) goto <D.48795>; else goto <D.48798>;
  <D.48798>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48211 = D.48208 + 64878;
  if (D.48211 <= 9) goto <D.48795>; else goto <D.48799>;
  <D.48799>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48213 = D.48208 + 64888;
  if (D.48213 <= 9) goto <D.48795>; else goto <D.48794>;
  <D.48795>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48214 = D.48176->data.op[1].many_blocks;
  D.48215 = D.48214 + 8;
  D.48216 = *D.48215;
  if (D.48216 == 0B) goto <D.48800>; else goto <D.48794>;
  <D.48800>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48214 = D.48176->data.op[1].many_blocks;
  D.48215 = D.48214 + 8;
  *D.48215 = end_bb;
  D.48175 = cfg->cbb;
  mono_link_bblock (cfg, D.48175, end_bb);
  goto <D.48796>;
  <D.48794>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  if (D.48176 == 0B) goto <D.48801>; else goto <D.48803>;
  <D.48803>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  if (D.48208 != 442) goto <D.48804>; else goto <D.48802>;
  <D.48804>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  if (D.48208 != 759) goto <D.48805>; else goto <D.48802>;
  <D.48805>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48209 = D.48208 + 64985;
  if (D.48209 > 9) goto <D.48806>; else goto <D.48802>;
  <D.48806>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48211 = D.48208 + 64878;
  if (D.48211 > 9) goto <D.48807>; else goto <D.48802>;
  <D.48807>:
  D.48175 = cfg->cbb;
  D.48176 = D.48175->last_ins;
  D.48208 = D.48176->opcode;
  D.48213 = D.48208 + 64888;
  if (D.48213 > 9) goto <D.48801>; else goto <D.48802>;
  <D.48801>:
  D.48175 = cfg->cbb;
  mono_link_bblock (cfg, D.48175, end_bb);
  <D.48802>:
  <D.48796>:
  D.48175 = cfg->cbb;
  D.48175->next_bb = end_bb;
  cfg->cbb = end_bb;
  D.48153 = cfg->mempool;
  ins = mono_mempool_alloc (D.48153, 80);
  ins->data.op[1].const_val = 0;
  D.48808 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.48808;
  ins->prev = 0B;
  D.48809 = ins->prev;
  ins->next = D.48809;
  ins->opcode = 362;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.48810 = ins->sreg3;
  ins->sreg2 = D.48810;
  D.48811 = ins->sreg2;
  ins->sreg1 = D.48811;
  D.48174 = cfg->ip;
  ins->cil_code = D.48174;
  ins->dreg = dreg;
  ins->type = 1;
  D.48812 = ins;
  return D.48812;
}


handle_ccastclass (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * src)
{
  unsigned int D.48814;
  unsigned int D.48815;
  unsigned int D.48816;
  struct MonoMemPool * D.48817;
  unsigned int D.48818;
  unsigned int D.48819;
  unsigned int D.48820;
  int D.48821;
  unsigned int D.48822;
  unsigned int D.48823;
  int D.48824;
  long int D.48825;
  struct MonoInst * D.48826;
  int D.48827;
  int D.48828;
  const unsigned char * D.48829;
  struct MonoBasicBlock * D.48830;
  struct MonoInst * D.48831;
  long int D.48835;
  struct MonoInst * D.48836;
  int D.48837;
  int D.48838;
  unsigned int D.48841;
  unsigned int D.48842;
  int D.48843;
  unsigned char * D.48847;
  struct MonoBasicBlock * * D.48850;
  long int D.48851;
  unsigned char * D.48852;
  long int D.48853;
  long int D.48854;
  long unsigned int D.48855;
  long unsigned int D.48856;
  struct MonoBasicBlock * * D.48857;
  unsigned int D.48858;
  short unsigned int D.48863;
  short unsigned int D.48864;
  short unsigned int D.48866;
  short unsigned int D.48868;
  struct MonoBasicBlock * * D.48869;
  struct MonoBasicBlock * * D.48870;
  struct MonoBasicBlock * D.48871;
  void * D.48881;
  struct MonoBasicBlock * * D.48882;
  struct MonoBasicBlock * * D.48883;
  long unsigned int D.48887;
  long unsigned int D.48888;
  unsigned int D.48891;
  unsigned int D.48892;
  int D.48893;
  unsigned int D.48911;
  unsigned int D.48912;
  unsigned int D.48915;
  unsigned int D.48916;
  int D.48917;
  long int D.48918;
  struct MonoInst * D.48919;
  int D.48920;
  int D.48921;
  unsigned char * D.48925;
  long int D.48928;
  long int D.48929;
  long unsigned int D.48930;
  long unsigned int D.48931;
  struct MonoBasicBlock * * D.48932;
  long int D.48947;
  struct MonoInst * D.48948;
  int D.48949;
  int D.48950;
  struct MonoClass * D.48954;
  unsigned int D.48955;
  long int D.48956;
  struct MonoInst * D.48957;
  int D.48958;
  int D.48959;
  long int D.48963;
  struct MonoInst * D.48964;
  int D.48965;
  int D.48966;
  long int D.48970;
  struct MonoInst * D.48971;
  int D.48972;
  int D.48973;
  long int D.48977;
  struct MonoInst * D.48978;
  int D.48979;
  int D.48980;
  long int D.48984;
  struct MonoInst * D.48985;
  int D.48986;
  int D.48987;
  unsigned int D.48990;
  unsigned int D.48991;
  int D.48992;
  unsigned char * D.48996;
  long int D.48999;
  long int D.49000;
  long unsigned int D.49001;
  long unsigned int D.49002;
  struct MonoBasicBlock * * D.49003;
  void * D.49019;
  struct MonoBasicBlock * * D.49020;
  struct MonoBasicBlock * * D.49021;
  unsigned int D.49027;
  unsigned int D.49028;
  int D.49029;
  unsigned int D.49048;
  unsigned int D.49049;
  int D.49050;
  long int D.49051;
  struct MonoInst * D.49052;
  int D.49053;
  int D.49054;
  long int D.49058;
  struct MonoInst * D.49059;
  int D.49060;
  int D.49061;
  unsigned int D.49065;
  long int D.49066;
  struct MonoInst * D.49067;
  int D.49068;
  int D.49069;
  long int D.49073;
  struct MonoInst * D.49074;
  int D.49075;
  int D.49076;
  unsigned int D.49080;
  long int D.49081;
  struct MonoInst * D.49082;
  int D.49083;
  int D.49084;
  long int D.49088;
  struct MonoInst * D.49089;
  int D.49090;
  int D.49091;
  long int D.49095;
  struct MonoInst * D.49096;
  int D.49097;
  int D.49098;
  unsigned int D.49101;
  unsigned int D.49102;
  int D.49103;
  unsigned char * D.49107;
  long int D.49110;
  long int D.49111;
  long unsigned int D.49112;
  long unsigned int D.49113;
  struct MonoBasicBlock * * D.49114;
  void * D.49130;
  struct MonoBasicBlock * * D.49131;
  struct MonoBasicBlock * * D.49132;
  unsigned int D.49138;
  unsigned int D.49139;
  int D.49140;
  unsigned int D.49158;
  unsigned int D.49159;
  int D.49160;
  unsigned char * D.49161;
  long int D.49164;
  long int D.49165;
  long unsigned int D.49166;
  long unsigned int D.49167;
  struct MonoBasicBlock * * D.49168;
  long int D.49183;
  struct MonoInst * D.49184;
  int D.49185;
  int D.49186;
  long int D.49190;
  struct MonoInst * D.49191;
  int D.49192;
  int D.49193;
  unsigned int D.49196;
  unsigned int D.49197;
  int D.49198;
  unsigned char * D.49202;
  long int D.49205;
  long int D.49206;
  long unsigned int D.49207;
  long unsigned int D.49208;
  struct MonoBasicBlock * * D.49209;
  void * D.49225;
  struct MonoBasicBlock * * D.49226;
  struct MonoBasicBlock * * D.49227;
  unsigned int D.49233;
  unsigned int D.49234;
  int D.49235;
  unsigned char * D.49253;
  long int D.49256;
  long int D.49257;
  long unsigned int D.49258;
  long unsigned int D.49259;
  struct MonoBasicBlock * * D.49260;
  unsigned char * D.49275;
  long int D.49278;
  long int D.49279;
  long unsigned int D.49280;
  long unsigned int D.49281;
  struct MonoBasicBlock * * D.49282;
  long int D.49297;
  struct MonoInst * D.49298;
  int D.49299;
  int D.49300;
  unsigned char * D.49304;
  long int D.49307;
  long int D.49308;
  long unsigned int D.49309;
  long unsigned int D.49310;
  struct MonoBasicBlock * * D.49311;
  long int D.49326;
  struct MonoInst * D.49327;
  int D.49328;
  int D.49329;
  struct MonoInst * D.49330;
  struct MonoInst * ins;
  struct MonoBasicBlock * end_bb;
  struct MonoBasicBlock * ok_result_bb;
  struct MonoBasicBlock * no_proxy_bb;
  struct MonoBasicBlock * interface_fail_bb;
  struct MonoBasicBlock * fail_1_bb;
  int obj_reg;
  int dreg;
  int tmp_reg;
  int klass_reg;

  obj_reg = src->dreg;
  D.48814 = alloc_ireg (cfg);
  dreg = (int) D.48814;
  D.48815 = alloc_preg (cfg);
  tmp_reg = (int) D.48815;
  D.48816 = alloc_preg (cfg);
  klass_reg = (int) D.48816;
  D.48817 = cfg->mempool;
  end_bb = mono_mempool_alloc0 (D.48817, 296);
  D.48818 = cfg->num_bblocks;
  D.48819 = D.48818;
  D.48820 = D.48819 + 1;
  cfg->num_bblocks = D.48820;
  D.48821 = (int) D.48819;
  end_bb->block_num = D.48821;
  D.48817 = cfg->mempool;
  ok_result_bb = mono_mempool_alloc0 (D.48817, 296);
  D.48818 = cfg->num_bblocks;
  D.48822 = D.48818;
  D.48823 = D.48822 + 1;
  cfg->num_bblocks = D.48823;
  D.48824 = (int) D.48822;
  ok_result_bb->block_num = D.48824;
  {
    struct MonoInst * inst;

    D.48817 = cfg->mempool;
    inst = mono_mempool_alloc (D.48817, 80);
    inst->data.op[1].const_val = 0;
    D.48825 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48825;
    inst->prev = 0B;
    D.48826 = inst->prev;
    inst->next = D.48826;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48827 = inst->sreg3;
    inst->sreg2 = D.48827;
    D.48828 = inst->sreg2;
    inst->sreg1 = D.48828;
    D.48829 = cfg->ip;
    inst->cil_code = D.48829;
    inst->dreg = -1;
    inst->sreg1 = obj_reg;
    inst->data.op[1].const_val = 0;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.48832>; else goto <D.48833>;
    <D.48832>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = inst;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    inst->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    goto <D.48834>;
    <D.48833>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.48834>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.48817 = cfg->mempool;
    ins = mono_mempool_alloc (D.48817, 80);
    ins->data.op[1].const_val = 0;
    D.48835 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.48835;
    ins->prev = 0B;
    D.48836 = ins->prev;
    ins->next = D.48836;
    ins->opcode = 551;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.48837 = ins->sreg3;
    ins->sreg2 = D.48837;
    D.48838 = ins->sreg2;
    ins->sreg1 = D.48838;
    D.48829 = cfg->ip;
    ins->cil_code = D.48829;
    if (0 != 0) goto <D.48839>; else goto <D.48840>;
    <D.48839>:
    D.48817 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48817, 296);
    D.48818 = cfg->num_bblocks;
    D.48841 = D.48818;
    D.48842 = D.48841 + 1;
    cfg->num_bblocks = D.48842;
    D.48843 = (int) D.48841;
    falsebb->block_num = D.48843;
    ins->data.op[0].target_block = ok_result_bb;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, ok_result_bb);
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.48844>; else goto <D.48845>;
    <D.48844>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = ins;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    ins->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = ins;
    goto <D.48846>;
    <D.48845>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = ins;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.48846>:
    D.48847 = falsebb->cil_code;
    if (D.48847 != 0B) goto <D.48848>; else goto <D.48849>;
    <D.48848>:
    D.48850 = cfg->cil_offset_to_bb;
    D.48847 = falsebb->cil_code;
    D.48851 = (long int) D.48847;
    D.48852 = cfg->cil_start;
    D.48853 = (long int) D.48852;
    D.48854 = D.48851 - D.48853;
    D.48855 = (long unsigned int) D.48854;
    D.48856 = D.48855 * 8;
    D.48857 = D.48850 + D.48856;
    *D.48857 = falsebb;
    <D.48849>:
    D.48858 = cfg->real_offset;
    falsebb->real_offset = D.48858;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.48862>; else goto <D.48859>;
    <D.48862>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48864 = D.48863 + 64985;
    if (D.48864 <= 9) goto <D.48860>; else goto <D.48865>;
    <D.48865>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48866 = D.48863 + 64878;
    if (D.48866 <= 9) goto <D.48860>; else goto <D.48867>;
    <D.48867>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48868 = D.48863 + 64888;
    if (D.48868 <= 9) goto <D.48860>; else goto <D.48859>;
    <D.48860>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48869 = D.48831->data.op[1].many_blocks;
    D.48870 = D.48869 + 8;
    D.48871 = *D.48870;
    if (D.48871 == 0B) goto <D.48872>; else goto <D.48859>;
    <D.48872>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48869 = D.48831->data.op[1].many_blocks;
    D.48870 = D.48869 + 8;
    *D.48870 = falsebb;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    goto <D.48861>;
    <D.48859>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 == 0B) goto <D.48873>; else goto <D.48875>;
    <D.48875>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    if (D.48863 != 442) goto <D.48876>; else goto <D.48874>;
    <D.48876>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    if (D.48863 != 759) goto <D.48877>; else goto <D.48874>;
    <D.48877>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48864 = D.48863 + 64985;
    if (D.48864 > 9) goto <D.48878>; else goto <D.48874>;
    <D.48878>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48866 = D.48863 + 64878;
    if (D.48866 > 9) goto <D.48879>; else goto <D.48874>;
    <D.48879>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48868 = D.48863 + 64888;
    if (D.48868 > 9) goto <D.48873>; else goto <D.48874>;
    <D.48873>:
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    <D.48874>:
    <D.48861>:
    D.48830 = cfg->cbb;
    D.48830->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.48880>;
    <D.48840>:
    D.48817 = cfg->mempool;
    D.48881 = mono_mempool_alloc (D.48817, 16);
    ins->data.op[1].many_blocks = D.48881;
    D.48882 = ins->data.op[1].many_blocks;
    *D.48882 = ok_result_bb;
    D.48882 = ins->data.op[1].many_blocks;
    D.48883 = D.48882 + 8;
    *D.48883 = 0B;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, ok_result_bb);
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.48884>; else goto <D.48885>;
    <D.48884>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = ins;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    ins->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = ins;
    goto <D.48886>;
    <D.48885>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = ins;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.48886>:
    D.48887 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.48888 = D.48887 & 268435456;
    if (D.48888 == 0) goto <D.48889>; else goto <D.48890>;
    <D.48889>:
    D.48817 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48817, 296);
    D.48818 = cfg->num_bblocks;
    D.48891 = D.48818;
    D.48892 = D.48891 + 1;
    cfg->num_bblocks = D.48892;
    D.48893 = (int) D.48891;
    falsebb->block_num = D.48893;
    D.48882 = ins->data.op[1].many_blocks;
    D.48883 = D.48882 + 8;
    *D.48883 = falsebb;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    D.48847 = falsebb->cil_code;
    if (D.48847 != 0B) goto <D.48894>; else goto <D.48895>;
    <D.48894>:
    D.48850 = cfg->cil_offset_to_bb;
    D.48847 = falsebb->cil_code;
    D.48851 = (long int) D.48847;
    D.48852 = cfg->cil_start;
    D.48853 = (long int) D.48852;
    D.48854 = D.48851 - D.48853;
    D.48855 = (long unsigned int) D.48854;
    D.48856 = D.48855 * 8;
    D.48857 = D.48850 + D.48856;
    *D.48857 = falsebb;
    <D.48895>:
    D.48858 = cfg->real_offset;
    falsebb->real_offset = D.48858;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.48899>; else goto <D.48896>;
    <D.48899>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48864 = D.48863 + 64985;
    if (D.48864 <= 9) goto <D.48897>; else goto <D.48900>;
    <D.48900>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48866 = D.48863 + 64878;
    if (D.48866 <= 9) goto <D.48897>; else goto <D.48901>;
    <D.48901>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48868 = D.48863 + 64888;
    if (D.48868 <= 9) goto <D.48897>; else goto <D.48896>;
    <D.48897>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48869 = D.48831->data.op[1].many_blocks;
    D.48870 = D.48869 + 8;
    D.48871 = *D.48870;
    if (D.48871 == 0B) goto <D.48902>; else goto <D.48896>;
    <D.48902>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48869 = D.48831->data.op[1].many_blocks;
    D.48870 = D.48869 + 8;
    *D.48870 = falsebb;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    goto <D.48898>;
    <D.48896>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 == 0B) goto <D.48903>; else goto <D.48905>;
    <D.48905>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    if (D.48863 != 442) goto <D.48906>; else goto <D.48904>;
    <D.48906>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    if (D.48863 != 759) goto <D.48907>; else goto <D.48904>;
    <D.48907>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48864 = D.48863 + 64985;
    if (D.48864 > 9) goto <D.48908>; else goto <D.48904>;
    <D.48908>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48866 = D.48863 + 64878;
    if (D.48866 > 9) goto <D.48909>; else goto <D.48904>;
    <D.48909>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48868 = D.48863 + 64888;
    if (D.48868 > 9) goto <D.48903>; else goto <D.48904>;
    <D.48903>:
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    <D.48904>:
    <D.48898>:
    D.48830 = cfg->cbb;
    D.48830->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.48910>;
    <D.48890>:
    D.48830 = cfg->cbb;
    D.48830->extended = 1;
    <D.48910>:
    <D.48880>:
  }
  save_cast_details (cfg, klass, obj_reg, 0, 0B);
  D.48911 = klass->flags;
  D.48912 = D.48911 & 32;
  if (D.48912 != 0) goto <D.48913>; else goto <D.48914>;
  <D.48913>:
  D.48817 = cfg->mempool;
  interface_fail_bb = mono_mempool_alloc0 (D.48817, 296);
  D.48818 = cfg->num_bblocks;
  D.48915 = D.48818;
  D.48916 = D.48915 + 1;
  cfg->num_bblocks = D.48916;
  D.48917 = (int) D.48915;
  interface_fail_bb->block_num = D.48917;
  {
    struct MonoInst * inst;

    D.48817 = cfg->mempool;
    inst = mono_mempool_alloc (D.48817, 80);
    inst->data.op[1].const_val = 0;
    D.48918 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48918;
    inst->prev = 0B;
    D.48919 = inst->prev;
    inst->next = D.48919;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48920 = inst->sreg3;
    inst->sreg2 = D.48920;
    D.48921 = inst->sreg2;
    inst->sreg1 = D.48921;
    D.48829 = cfg->ip;
    inst->cil_code = D.48829;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 0;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.48922>; else goto <D.48923>;
    <D.48922>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = inst;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    inst->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    goto <D.48924>;
    <D.48923>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.48924>:
  }
  mini_emit_iface_cast (cfg, tmp_reg, klass, interface_fail_bb, ok_result_bb);
  D.48925 = interface_fail_bb->cil_code;
  if (D.48925 != 0B) goto <D.48926>; else goto <D.48927>;
  <D.48926>:
  D.48850 = cfg->cil_offset_to_bb;
  D.48925 = interface_fail_bb->cil_code;
  D.48928 = (long int) D.48925;
  D.48852 = cfg->cil_start;
  D.48853 = (long int) D.48852;
  D.48929 = D.48928 - D.48853;
  D.48930 = (long unsigned int) D.48929;
  D.48931 = D.48930 * 8;
  D.48932 = D.48850 + D.48931;
  *D.48932 = interface_fail_bb;
  <D.48927>:
  D.48858 = cfg->real_offset;
  interface_fail_bb->real_offset = D.48858;
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  if (D.48831 != 0B) goto <D.48936>; else goto <D.48933>;
  <D.48936>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48864 = D.48863 + 64985;
  if (D.48864 <= 9) goto <D.48934>; else goto <D.48937>;
  <D.48937>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48866 = D.48863 + 64878;
  if (D.48866 <= 9) goto <D.48934>; else goto <D.48938>;
  <D.48938>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48868 = D.48863 + 64888;
  if (D.48868 <= 9) goto <D.48934>; else goto <D.48933>;
  <D.48934>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48869 = D.48831->data.op[1].many_blocks;
  D.48870 = D.48869 + 8;
  D.48871 = *D.48870;
  if (D.48871 == 0B) goto <D.48939>; else goto <D.48933>;
  <D.48939>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48869 = D.48831->data.op[1].many_blocks;
  D.48870 = D.48869 + 8;
  *D.48870 = interface_fail_bb;
  D.48830 = cfg->cbb;
  mono_link_bblock (cfg, D.48830, interface_fail_bb);
  goto <D.48935>;
  <D.48933>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  if (D.48831 == 0B) goto <D.48940>; else goto <D.48942>;
  <D.48942>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  if (D.48863 != 442) goto <D.48943>; else goto <D.48941>;
  <D.48943>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  if (D.48863 != 759) goto <D.48944>; else goto <D.48941>;
  <D.48944>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48864 = D.48863 + 64985;
  if (D.48864 > 9) goto <D.48945>; else goto <D.48941>;
  <D.48945>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48866 = D.48863 + 64878;
  if (D.48866 > 9) goto <D.48946>; else goto <D.48941>;
  <D.48946>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48868 = D.48863 + 64888;
  if (D.48868 > 9) goto <D.48940>; else goto <D.48941>;
  <D.48940>:
  D.48830 = cfg->cbb;
  mono_link_bblock (cfg, D.48830, interface_fail_bb);
  <D.48941>:
  <D.48935>:
  D.48830 = cfg->cbb;
  D.48830->next_bb = interface_fail_bb;
  cfg->cbb = interface_fail_bb;
  {
    struct MonoInst * inst;

    D.48817 = cfg->mempool;
    inst = mono_mempool_alloc (D.48817, 80);
    inst->data.op[1].const_val = 0;
    D.48947 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48947;
    inst->prev = 0B;
    D.48948 = inst->prev;
    inst->next = D.48948;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48949 = inst->sreg3;
    inst->sreg2 = D.48949;
    D.48950 = inst->sreg2;
    inst->sreg1 = D.48950;
    D.48829 = cfg->ip;
    inst->cil_code = D.48829;
    inst->dreg = klass_reg;
    inst->sreg1 = tmp_reg;
    inst->data.op[0].const_val = 0;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.48951>; else goto <D.48952>;
    <D.48951>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = inst;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    inst->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    goto <D.48953>;
    <D.48952>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.48953>:
  }
  D.48954 = mono_defaults.transparent_proxy_class;
  mini_emit_class_check (cfg, klass_reg, D.48954);
  D.48955 = alloc_preg (cfg);
  tmp_reg = (int) D.48955;
  {
    struct MonoInst * inst;

    D.48817 = cfg->mempool;
    inst = mono_mempool_alloc (D.48817, 80);
    inst->data.op[1].const_val = 0;
    D.48956 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48956;
    inst->prev = 0B;
    D.48957 = inst->prev;
    inst->next = D.48957;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48958 = inst->sreg3;
    inst->sreg2 = D.48958;
    D.48959 = inst->sreg2;
    inst->sreg1 = D.48959;
    D.48829 = cfg->ip;
    inst->cil_code = D.48829;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 32;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.48960>; else goto <D.48961>;
    <D.48960>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = inst;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    inst->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    goto <D.48962>;
    <D.48961>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.48962>:
  }
  {
    struct MonoInst * inst;

    D.48817 = cfg->mempool;
    inst = mono_mempool_alloc (D.48817, 80);
    inst->data.op[1].const_val = 0;
    D.48963 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48963;
    inst->prev = 0B;
    D.48964 = inst->prev;
    inst->next = D.48964;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48965 = inst->sreg3;
    inst->sreg2 = D.48965;
    D.48966 = inst->sreg2;
    inst->sreg1 = D.48966;
    D.48829 = cfg->ip;
    inst->cil_code = D.48829;
    inst->dreg = -1;
    inst->sreg1 = tmp_reg;
    inst->data.op[1].const_val = 0;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.48967>; else goto <D.48968>;
    <D.48967>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = inst;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    inst->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    goto <D.48969>;
    <D.48968>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.48969>:
  }
  {
    struct MonoInst * inst;

    D.48817 = cfg->mempool;
    inst = mono_mempool_alloc (D.48817, 80);
    inst->data.op[1].const_val = 0;
    D.48970 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48970;
    inst->prev = 0B;
    D.48971 = inst->prev;
    inst->next = D.48971;
    inst->opcode = 451;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48972 = inst->sreg3;
    inst->sreg2 = D.48972;
    D.48973 = inst->sreg2;
    inst->sreg1 = D.48973;
    D.48829 = cfg->ip;
    inst->cil_code = D.48829;
    inst->data.op[1].p = "InvalidCastException";
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.48974>; else goto <D.48975>;
    <D.48974>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = inst;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    inst->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    goto <D.48976>;
    <D.48975>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.48976>:
  }
  {
    struct MonoInst * inst;

    D.48817 = cfg->mempool;
    inst = mono_mempool_alloc (D.48817, 80);
    inst->data.op[1].const_val = 0;
    D.48977 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.48977;
    inst->prev = 0B;
    D.48978 = inst->prev;
    inst->next = D.48978;
    inst->opcode = 362;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.48979 = inst->sreg3;
    inst->sreg2 = D.48979;
    D.48980 = inst->sreg2;
    inst->sreg1 = D.48980;
    D.48829 = cfg->ip;
    inst->cil_code = D.48829;
    inst->dreg = dreg;
    inst->data.op[0].const_val = 1;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.48981>; else goto <D.48982>;
    <D.48981>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = inst;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    inst->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    goto <D.48983>;
    <D.48982>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.48983>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.48817 = cfg->mempool;
    ins = mono_mempool_alloc (D.48817, 80);
    ins->data.op[1].const_val = 0;
    D.48984 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.48984;
    ins->prev = 0B;
    D.48985 = ins->prev;
    ins->next = D.48985;
    ins->opcode = 442;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.48986 = ins->sreg3;
    ins->sreg2 = D.48986;
    D.48987 = ins->sreg2;
    ins->sreg1 = D.48987;
    D.48829 = cfg->ip;
    ins->cil_code = D.48829;
    if (1 != 0) goto <D.48988>; else goto <D.48989>;
    <D.48988>:
    D.48817 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48817, 296);
    D.48818 = cfg->num_bblocks;
    D.48990 = D.48818;
    D.48991 = D.48990 + 1;
    cfg->num_bblocks = D.48991;
    D.48992 = (int) D.48990;
    falsebb->block_num = D.48992;
    ins->data.op[0].target_block = end_bb;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, end_bb);
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.48993>; else goto <D.48994>;
    <D.48993>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = ins;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    ins->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = ins;
    goto <D.48995>;
    <D.48994>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = ins;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.48995>:
    D.48996 = falsebb->cil_code;
    if (D.48996 != 0B) goto <D.48997>; else goto <D.48998>;
    <D.48997>:
    D.48850 = cfg->cil_offset_to_bb;
    D.48996 = falsebb->cil_code;
    D.48999 = (long int) D.48996;
    D.48852 = cfg->cil_start;
    D.48853 = (long int) D.48852;
    D.49000 = D.48999 - D.48853;
    D.49001 = (long unsigned int) D.49000;
    D.49002 = D.49001 * 8;
    D.49003 = D.48850 + D.49002;
    *D.49003 = falsebb;
    <D.48998>:
    D.48858 = cfg->real_offset;
    falsebb->real_offset = D.48858;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.49007>; else goto <D.49004>;
    <D.49007>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48864 = D.48863 + 64985;
    if (D.48864 <= 9) goto <D.49005>; else goto <D.49008>;
    <D.49008>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48866 = D.48863 + 64878;
    if (D.48866 <= 9) goto <D.49005>; else goto <D.49009>;
    <D.49009>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48868 = D.48863 + 64888;
    if (D.48868 <= 9) goto <D.49005>; else goto <D.49004>;
    <D.49005>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48869 = D.48831->data.op[1].many_blocks;
    D.48870 = D.48869 + 8;
    D.48871 = *D.48870;
    if (D.48871 == 0B) goto <D.49010>; else goto <D.49004>;
    <D.49010>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48869 = D.48831->data.op[1].many_blocks;
    D.48870 = D.48869 + 8;
    *D.48870 = falsebb;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    goto <D.49006>;
    <D.49004>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 == 0B) goto <D.49011>; else goto <D.49013>;
    <D.49013>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    if (D.48863 != 442) goto <D.49014>; else goto <D.49012>;
    <D.49014>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    if (D.48863 != 759) goto <D.49015>; else goto <D.49012>;
    <D.49015>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48864 = D.48863 + 64985;
    if (D.48864 > 9) goto <D.49016>; else goto <D.49012>;
    <D.49016>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48866 = D.48863 + 64878;
    if (D.48866 > 9) goto <D.49017>; else goto <D.49012>;
    <D.49017>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48868 = D.48863 + 64888;
    if (D.48868 > 9) goto <D.49011>; else goto <D.49012>;
    <D.49011>:
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    <D.49012>:
    <D.49006>:
    D.48830 = cfg->cbb;
    D.48830->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.49018>;
    <D.48989>:
    D.48817 = cfg->mempool;
    D.49019 = mono_mempool_alloc (D.48817, 16);
    ins->data.op[1].many_blocks = D.49019;
    D.49020 = ins->data.op[1].many_blocks;
    *D.49020 = end_bb;
    D.49020 = ins->data.op[1].many_blocks;
    D.49021 = D.49020 + 8;
    *D.49021 = 0B;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, end_bb);
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.49022>; else goto <D.49023>;
    <D.49022>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = ins;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    ins->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = ins;
    goto <D.49024>;
    <D.49023>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = ins;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.49024>:
    D.48887 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.48888 = D.48887 & 268435456;
    if (D.48888 == 0) goto <D.49025>; else goto <D.49026>;
    <D.49025>:
    D.48817 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48817, 296);
    D.48818 = cfg->num_bblocks;
    D.49027 = D.48818;
    D.49028 = D.49027 + 1;
    cfg->num_bblocks = D.49028;
    D.49029 = (int) D.49027;
    falsebb->block_num = D.49029;
    D.49020 = ins->data.op[1].many_blocks;
    D.49021 = D.49020 + 8;
    *D.49021 = falsebb;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    D.48996 = falsebb->cil_code;
    if (D.48996 != 0B) goto <D.49030>; else goto <D.49031>;
    <D.49030>:
    D.48850 = cfg->cil_offset_to_bb;
    D.48996 = falsebb->cil_code;
    D.48999 = (long int) D.48996;
    D.48852 = cfg->cil_start;
    D.48853 = (long int) D.48852;
    D.49000 = D.48999 - D.48853;
    D.49001 = (long unsigned int) D.49000;
    D.49002 = D.49001 * 8;
    D.49003 = D.48850 + D.49002;
    *D.49003 = falsebb;
    <D.49031>:
    D.48858 = cfg->real_offset;
    falsebb->real_offset = D.48858;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.49035>; else goto <D.49032>;
    <D.49035>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48864 = D.48863 + 64985;
    if (D.48864 <= 9) goto <D.49033>; else goto <D.49036>;
    <D.49036>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48866 = D.48863 + 64878;
    if (D.48866 <= 9) goto <D.49033>; else goto <D.49037>;
    <D.49037>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48868 = D.48863 + 64888;
    if (D.48868 <= 9) goto <D.49033>; else goto <D.49032>;
    <D.49033>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48869 = D.48831->data.op[1].many_blocks;
    D.48870 = D.48869 + 8;
    D.48871 = *D.48870;
    if (D.48871 == 0B) goto <D.49038>; else goto <D.49032>;
    <D.49038>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48869 = D.48831->data.op[1].many_blocks;
    D.48870 = D.48869 + 8;
    *D.48870 = falsebb;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    goto <D.49034>;
    <D.49032>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 == 0B) goto <D.49039>; else goto <D.49041>;
    <D.49041>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    if (D.48863 != 442) goto <D.49042>; else goto <D.49040>;
    <D.49042>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    if (D.48863 != 759) goto <D.49043>; else goto <D.49040>;
    <D.49043>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48864 = D.48863 + 64985;
    if (D.48864 > 9) goto <D.49044>; else goto <D.49040>;
    <D.49044>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48866 = D.48863 + 64878;
    if (D.48866 > 9) goto <D.49045>; else goto <D.49040>;
    <D.49045>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48868 = D.48863 + 64888;
    if (D.48868 > 9) goto <D.49039>; else goto <D.49040>;
    <D.49039>:
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    <D.49040>:
    <D.49034>:
    D.48830 = cfg->cbb;
    D.48830->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.49046>;
    <D.49026>:
    D.48830 = cfg->cbb;
    D.48830->extended = 1;
    <D.49046>:
    <D.49018>:
  }
  goto <D.49047>;
  <D.48914>:
  D.48817 = cfg->mempool;
  no_proxy_bb = mono_mempool_alloc0 (D.48817, 296);
  D.48818 = cfg->num_bblocks;
  D.49048 = D.48818;
  D.49049 = D.49048 + 1;
  cfg->num_bblocks = D.49049;
  D.49050 = (int) D.49048;
  no_proxy_bb->block_num = D.49050;
  {
    struct MonoInst * inst;

    D.48817 = cfg->mempool;
    inst = mono_mempool_alloc (D.48817, 80);
    inst->data.op[1].const_val = 0;
    D.49051 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.49051;
    inst->prev = 0B;
    D.49052 = inst->prev;
    inst->next = D.49052;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.49053 = inst->sreg3;
    inst->sreg2 = D.49053;
    D.49054 = inst->sreg2;
    inst->sreg1 = D.49054;
    D.48829 = cfg->ip;
    inst->cil_code = D.48829;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 0;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.49055>; else goto <D.49056>;
    <D.49055>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = inst;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    inst->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    goto <D.49057>;
    <D.49056>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.49057>:
  }
  {
    struct MonoInst * inst;

    D.48817 = cfg->mempool;
    inst = mono_mempool_alloc (D.48817, 80);
    inst->data.op[1].const_val = 0;
    D.49058 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.49058;
    inst->prev = 0B;
    D.49059 = inst->prev;
    inst->next = D.49059;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.49060 = inst->sreg3;
    inst->sreg2 = D.49060;
    D.49061 = inst->sreg2;
    inst->sreg1 = D.49061;
    D.48829 = cfg->ip;
    inst->cil_code = D.48829;
    inst->dreg = klass_reg;
    inst->sreg1 = tmp_reg;
    inst->data.op[0].const_val = 0;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.49062>; else goto <D.49063>;
    <D.49062>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = inst;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    inst->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    goto <D.49064>;
    <D.49063>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.49064>:
  }
  D.48954 = mono_defaults.transparent_proxy_class;
  mini_emit_class_check_branch (cfg, klass_reg, D.48954, 556, no_proxy_bb);
  D.49065 = alloc_preg (cfg);
  tmp_reg = (int) D.49065;
  {
    struct MonoInst * inst;

    D.48817 = cfg->mempool;
    inst = mono_mempool_alloc (D.48817, 80);
    inst->data.op[1].const_val = 0;
    D.49066 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.49066;
    inst->prev = 0B;
    D.49067 = inst->prev;
    inst->next = D.49067;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.49068 = inst->sreg3;
    inst->sreg2 = D.49068;
    D.49069 = inst->sreg2;
    inst->sreg1 = D.49069;
    D.48829 = cfg->ip;
    inst->cil_code = D.48829;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 24;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.49070>; else goto <D.49071>;
    <D.49070>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = inst;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    inst->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    goto <D.49072>;
    <D.49071>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.49072>:
  }
  {
    struct MonoInst * inst;

    D.48817 = cfg->mempool;
    inst = mono_mempool_alloc (D.48817, 80);
    inst->data.op[1].const_val = 0;
    D.49073 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.49073;
    inst->prev = 0B;
    D.49074 = inst->prev;
    inst->next = D.49074;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.49075 = inst->sreg3;
    inst->sreg2 = D.49075;
    D.49076 = inst->sreg2;
    inst->sreg1 = D.49076;
    D.48829 = cfg->ip;
    inst->cil_code = D.48829;
    inst->dreg = klass_reg;
    inst->sreg1 = tmp_reg;
    inst->data.op[0].const_val = 16;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.49077>; else goto <D.49078>;
    <D.49077>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = inst;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    inst->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    goto <D.49079>;
    <D.49078>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.49079>:
  }
  D.49080 = alloc_preg (cfg);
  tmp_reg = (int) D.49080;
  {
    struct MonoInst * inst;

    D.48817 = cfg->mempool;
    inst = mono_mempool_alloc (D.48817, 80);
    inst->data.op[1].const_val = 0;
    D.49081 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.49081;
    inst->prev = 0B;
    D.49082 = inst->prev;
    inst->next = D.49082;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.49083 = inst->sreg3;
    inst->sreg2 = D.49083;
    D.49084 = inst->sreg2;
    inst->sreg1 = D.49084;
    D.48829 = cfg->ip;
    inst->cil_code = D.48829;
    inst->dreg = tmp_reg;
    inst->sreg1 = obj_reg;
    inst->data.op[0].const_val = 32;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.49085>; else goto <D.49086>;
    <D.49085>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = inst;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    inst->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    goto <D.49087>;
    <D.49086>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.49087>:
  }
  {
    struct MonoInst * inst;

    D.48817 = cfg->mempool;
    inst = mono_mempool_alloc (D.48817, 80);
    inst->data.op[1].const_val = 0;
    D.49088 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.49088;
    inst->prev = 0B;
    D.49089 = inst->prev;
    inst->next = D.49089;
    inst->opcode = 323;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.49090 = inst->sreg3;
    inst->sreg2 = D.49090;
    D.49091 = inst->sreg2;
    inst->sreg1 = D.49091;
    D.48829 = cfg->ip;
    inst->cil_code = D.48829;
    inst->dreg = -1;
    inst->sreg1 = tmp_reg;
    inst->data.op[1].const_val = 0;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.49092>; else goto <D.49093>;
    <D.49092>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = inst;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    inst->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    goto <D.49094>;
    <D.49093>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.49094>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.48817 = cfg->mempool;
    ins = mono_mempool_alloc (D.48817, 80);
    ins->data.op[1].const_val = 0;
    D.49095 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.49095;
    ins->prev = 0B;
    D.49096 = ins->prev;
    ins->next = D.49096;
    ins->opcode = 551;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.49097 = ins->sreg3;
    ins->sreg2 = D.49097;
    D.49098 = ins->sreg2;
    ins->sreg1 = D.49098;
    D.48829 = cfg->ip;
    ins->cil_code = D.48829;
    if (0 != 0) goto <D.49099>; else goto <D.49100>;
    <D.49099>:
    D.48817 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48817, 296);
    D.48818 = cfg->num_bblocks;
    D.49101 = D.48818;
    D.49102 = D.49101 + 1;
    cfg->num_bblocks = D.49102;
    D.49103 = (int) D.49101;
    falsebb->block_num = D.49103;
    ins->data.op[0].target_block = no_proxy_bb;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, no_proxy_bb);
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.49104>; else goto <D.49105>;
    <D.49104>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = ins;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    ins->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = ins;
    goto <D.49106>;
    <D.49105>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = ins;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.49106>:
    D.49107 = falsebb->cil_code;
    if (D.49107 != 0B) goto <D.49108>; else goto <D.49109>;
    <D.49108>:
    D.48850 = cfg->cil_offset_to_bb;
    D.49107 = falsebb->cil_code;
    D.49110 = (long int) D.49107;
    D.48852 = cfg->cil_start;
    D.48853 = (long int) D.48852;
    D.49111 = D.49110 - D.48853;
    D.49112 = (long unsigned int) D.49111;
    D.49113 = D.49112 * 8;
    D.49114 = D.48850 + D.49113;
    *D.49114 = falsebb;
    <D.49109>:
    D.48858 = cfg->real_offset;
    falsebb->real_offset = D.48858;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.49118>; else goto <D.49115>;
    <D.49118>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48864 = D.48863 + 64985;
    if (D.48864 <= 9) goto <D.49116>; else goto <D.49119>;
    <D.49119>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48866 = D.48863 + 64878;
    if (D.48866 <= 9) goto <D.49116>; else goto <D.49120>;
    <D.49120>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48868 = D.48863 + 64888;
    if (D.48868 <= 9) goto <D.49116>; else goto <D.49115>;
    <D.49116>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48869 = D.48831->data.op[1].many_blocks;
    D.48870 = D.48869 + 8;
    D.48871 = *D.48870;
    if (D.48871 == 0B) goto <D.49121>; else goto <D.49115>;
    <D.49121>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48869 = D.48831->data.op[1].many_blocks;
    D.48870 = D.48869 + 8;
    *D.48870 = falsebb;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    goto <D.49117>;
    <D.49115>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 == 0B) goto <D.49122>; else goto <D.49124>;
    <D.49124>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    if (D.48863 != 442) goto <D.49125>; else goto <D.49123>;
    <D.49125>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    if (D.48863 != 759) goto <D.49126>; else goto <D.49123>;
    <D.49126>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48864 = D.48863 + 64985;
    if (D.48864 > 9) goto <D.49127>; else goto <D.49123>;
    <D.49127>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48866 = D.48863 + 64878;
    if (D.48866 > 9) goto <D.49128>; else goto <D.49123>;
    <D.49128>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48868 = D.48863 + 64888;
    if (D.48868 > 9) goto <D.49122>; else goto <D.49123>;
    <D.49122>:
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    <D.49123>:
    <D.49117>:
    D.48830 = cfg->cbb;
    D.48830->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.49129>;
    <D.49100>:
    D.48817 = cfg->mempool;
    D.49130 = mono_mempool_alloc (D.48817, 16);
    ins->data.op[1].many_blocks = D.49130;
    D.49131 = ins->data.op[1].many_blocks;
    *D.49131 = no_proxy_bb;
    D.49131 = ins->data.op[1].many_blocks;
    D.49132 = D.49131 + 8;
    *D.49132 = 0B;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, no_proxy_bb);
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.49133>; else goto <D.49134>;
    <D.49133>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = ins;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    ins->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = ins;
    goto <D.49135>;
    <D.49134>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = ins;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.49135>:
    D.48887 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.48888 = D.48887 & 268435456;
    if (D.48888 == 0) goto <D.49136>; else goto <D.49137>;
    <D.49136>:
    D.48817 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48817, 296);
    D.48818 = cfg->num_bblocks;
    D.49138 = D.48818;
    D.49139 = D.49138 + 1;
    cfg->num_bblocks = D.49139;
    D.49140 = (int) D.49138;
    falsebb->block_num = D.49140;
    D.49131 = ins->data.op[1].many_blocks;
    D.49132 = D.49131 + 8;
    *D.49132 = falsebb;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    D.49107 = falsebb->cil_code;
    if (D.49107 != 0B) goto <D.49141>; else goto <D.49142>;
    <D.49141>:
    D.48850 = cfg->cil_offset_to_bb;
    D.49107 = falsebb->cil_code;
    D.49110 = (long int) D.49107;
    D.48852 = cfg->cil_start;
    D.48853 = (long int) D.48852;
    D.49111 = D.49110 - D.48853;
    D.49112 = (long unsigned int) D.49111;
    D.49113 = D.49112 * 8;
    D.49114 = D.48850 + D.49113;
    *D.49114 = falsebb;
    <D.49142>:
    D.48858 = cfg->real_offset;
    falsebb->real_offset = D.48858;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.49146>; else goto <D.49143>;
    <D.49146>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48864 = D.48863 + 64985;
    if (D.48864 <= 9) goto <D.49144>; else goto <D.49147>;
    <D.49147>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48866 = D.48863 + 64878;
    if (D.48866 <= 9) goto <D.49144>; else goto <D.49148>;
    <D.49148>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48868 = D.48863 + 64888;
    if (D.48868 <= 9) goto <D.49144>; else goto <D.49143>;
    <D.49144>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48869 = D.48831->data.op[1].many_blocks;
    D.48870 = D.48869 + 8;
    D.48871 = *D.48870;
    if (D.48871 == 0B) goto <D.49149>; else goto <D.49143>;
    <D.49149>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48869 = D.48831->data.op[1].many_blocks;
    D.48870 = D.48869 + 8;
    *D.48870 = falsebb;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    goto <D.49145>;
    <D.49143>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 == 0B) goto <D.49150>; else goto <D.49152>;
    <D.49152>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    if (D.48863 != 442) goto <D.49153>; else goto <D.49151>;
    <D.49153>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    if (D.48863 != 759) goto <D.49154>; else goto <D.49151>;
    <D.49154>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48864 = D.48863 + 64985;
    if (D.48864 > 9) goto <D.49155>; else goto <D.49151>;
    <D.49155>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48866 = D.48863 + 64878;
    if (D.48866 > 9) goto <D.49156>; else goto <D.49151>;
    <D.49156>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48868 = D.48863 + 64888;
    if (D.48868 > 9) goto <D.49150>; else goto <D.49151>;
    <D.49150>:
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    <D.49151>:
    <D.49145>:
    D.48830 = cfg->cbb;
    D.48830->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.49157>;
    <D.49137>:
    D.48830 = cfg->cbb;
    D.48830->extended = 1;
    <D.49157>:
    <D.49129>:
  }
  D.48817 = cfg->mempool;
  fail_1_bb = mono_mempool_alloc0 (D.48817, 296);
  D.48818 = cfg->num_bblocks;
  D.49158 = D.48818;
  D.49159 = D.49158 + 1;
  cfg->num_bblocks = D.49159;
  D.49160 = (int) D.49158;
  fail_1_bb->block_num = D.49160;
  mini_emit_isninst_cast (cfg, klass_reg, klass, fail_1_bb, ok_result_bb);
  D.49161 = fail_1_bb->cil_code;
  if (D.49161 != 0B) goto <D.49162>; else goto <D.49163>;
  <D.49162>:
  D.48850 = cfg->cil_offset_to_bb;
  D.49161 = fail_1_bb->cil_code;
  D.49164 = (long int) D.49161;
  D.48852 = cfg->cil_start;
  D.48853 = (long int) D.48852;
  D.49165 = D.49164 - D.48853;
  D.49166 = (long unsigned int) D.49165;
  D.49167 = D.49166 * 8;
  D.49168 = D.48850 + D.49167;
  *D.49168 = fail_1_bb;
  <D.49163>:
  D.48858 = cfg->real_offset;
  fail_1_bb->real_offset = D.48858;
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  if (D.48831 != 0B) goto <D.49172>; else goto <D.49169>;
  <D.49172>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48864 = D.48863 + 64985;
  if (D.48864 <= 9) goto <D.49170>; else goto <D.49173>;
  <D.49173>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48866 = D.48863 + 64878;
  if (D.48866 <= 9) goto <D.49170>; else goto <D.49174>;
  <D.49174>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48868 = D.48863 + 64888;
  if (D.48868 <= 9) goto <D.49170>; else goto <D.49169>;
  <D.49170>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48869 = D.48831->data.op[1].many_blocks;
  D.48870 = D.48869 + 8;
  D.48871 = *D.48870;
  if (D.48871 == 0B) goto <D.49175>; else goto <D.49169>;
  <D.49175>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48869 = D.48831->data.op[1].many_blocks;
  D.48870 = D.48869 + 8;
  *D.48870 = fail_1_bb;
  D.48830 = cfg->cbb;
  mono_link_bblock (cfg, D.48830, fail_1_bb);
  goto <D.49171>;
  <D.49169>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  if (D.48831 == 0B) goto <D.49176>; else goto <D.49178>;
  <D.49178>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  if (D.48863 != 442) goto <D.49179>; else goto <D.49177>;
  <D.49179>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  if (D.48863 != 759) goto <D.49180>; else goto <D.49177>;
  <D.49180>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48864 = D.48863 + 64985;
  if (D.48864 > 9) goto <D.49181>; else goto <D.49177>;
  <D.49181>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48866 = D.48863 + 64878;
  if (D.48866 > 9) goto <D.49182>; else goto <D.49177>;
  <D.49182>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48868 = D.48863 + 64888;
  if (D.48868 > 9) goto <D.49176>; else goto <D.49177>;
  <D.49176>:
  D.48830 = cfg->cbb;
  mono_link_bblock (cfg, D.48830, fail_1_bb);
  <D.49177>:
  <D.49171>:
  D.48830 = cfg->cbb;
  D.48830->next_bb = fail_1_bb;
  cfg->cbb = fail_1_bb;
  {
    struct MonoInst * inst;

    D.48817 = cfg->mempool;
    inst = mono_mempool_alloc (D.48817, 80);
    inst->data.op[1].const_val = 0;
    D.49183 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.49183;
    inst->prev = 0B;
    D.49184 = inst->prev;
    inst->next = D.49184;
    inst->opcode = 362;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.49185 = inst->sreg3;
    inst->sreg2 = D.49185;
    D.49186 = inst->sreg2;
    inst->sreg1 = D.49186;
    D.48829 = cfg->ip;
    inst->cil_code = D.48829;
    inst->dreg = dreg;
    inst->data.op[0].const_val = 1;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.49187>; else goto <D.49188>;
    <D.49187>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = inst;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    inst->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    goto <D.49189>;
    <D.49188>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.49189>:
  }
  {
    struct MonoInst * ins;
    struct MonoBasicBlock * falsebb;

    D.48817 = cfg->mempool;
    ins = mono_mempool_alloc (D.48817, 80);
    ins->data.op[1].const_val = 0;
    D.49190 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.49190;
    ins->prev = 0B;
    D.49191 = ins->prev;
    ins->next = D.49191;
    ins->opcode = 442;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.49192 = ins->sreg3;
    ins->sreg2 = D.49192;
    D.49193 = ins->sreg2;
    ins->sreg1 = D.49193;
    D.48829 = cfg->ip;
    ins->cil_code = D.48829;
    if (1 != 0) goto <D.49194>; else goto <D.49195>;
    <D.49194>:
    D.48817 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48817, 296);
    D.48818 = cfg->num_bblocks;
    D.49196 = D.48818;
    D.49197 = D.49196 + 1;
    cfg->num_bblocks = D.49197;
    D.49198 = (int) D.49196;
    falsebb->block_num = D.49198;
    ins->data.op[0].target_block = end_bb;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, end_bb);
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.49199>; else goto <D.49200>;
    <D.49199>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = ins;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    ins->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = ins;
    goto <D.49201>;
    <D.49200>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = ins;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.49201>:
    D.49202 = falsebb->cil_code;
    if (D.49202 != 0B) goto <D.49203>; else goto <D.49204>;
    <D.49203>:
    D.48850 = cfg->cil_offset_to_bb;
    D.49202 = falsebb->cil_code;
    D.49205 = (long int) D.49202;
    D.48852 = cfg->cil_start;
    D.48853 = (long int) D.48852;
    D.49206 = D.49205 - D.48853;
    D.49207 = (long unsigned int) D.49206;
    D.49208 = D.49207 * 8;
    D.49209 = D.48850 + D.49208;
    *D.49209 = falsebb;
    <D.49204>:
    D.48858 = cfg->real_offset;
    falsebb->real_offset = D.48858;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.49213>; else goto <D.49210>;
    <D.49213>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48864 = D.48863 + 64985;
    if (D.48864 <= 9) goto <D.49211>; else goto <D.49214>;
    <D.49214>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48866 = D.48863 + 64878;
    if (D.48866 <= 9) goto <D.49211>; else goto <D.49215>;
    <D.49215>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48868 = D.48863 + 64888;
    if (D.48868 <= 9) goto <D.49211>; else goto <D.49210>;
    <D.49211>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48869 = D.48831->data.op[1].many_blocks;
    D.48870 = D.48869 + 8;
    D.48871 = *D.48870;
    if (D.48871 == 0B) goto <D.49216>; else goto <D.49210>;
    <D.49216>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48869 = D.48831->data.op[1].many_blocks;
    D.48870 = D.48869 + 8;
    *D.48870 = falsebb;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    goto <D.49212>;
    <D.49210>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 == 0B) goto <D.49217>; else goto <D.49219>;
    <D.49219>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    if (D.48863 != 442) goto <D.49220>; else goto <D.49218>;
    <D.49220>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    if (D.48863 != 759) goto <D.49221>; else goto <D.49218>;
    <D.49221>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48864 = D.48863 + 64985;
    if (D.48864 > 9) goto <D.49222>; else goto <D.49218>;
    <D.49222>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48866 = D.48863 + 64878;
    if (D.48866 > 9) goto <D.49223>; else goto <D.49218>;
    <D.49223>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48868 = D.48863 + 64888;
    if (D.48868 > 9) goto <D.49217>; else goto <D.49218>;
    <D.49217>:
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    <D.49218>:
    <D.49212>:
    D.48830 = cfg->cbb;
    D.48830->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.49224>;
    <D.49195>:
    D.48817 = cfg->mempool;
    D.49225 = mono_mempool_alloc (D.48817, 16);
    ins->data.op[1].many_blocks = D.49225;
    D.49226 = ins->data.op[1].many_blocks;
    *D.49226 = end_bb;
    D.49226 = ins->data.op[1].many_blocks;
    D.49227 = D.49226 + 8;
    *D.49227 = 0B;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, end_bb);
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.49228>; else goto <D.49229>;
    <D.49228>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = ins;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    ins->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = ins;
    goto <D.49230>;
    <D.49229>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = ins;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.49230>:
    D.48887 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.48888 = D.48887 & 268435456;
    if (D.48888 == 0) goto <D.49231>; else goto <D.49232>;
    <D.49231>:
    D.48817 = cfg->mempool;
    falsebb = mono_mempool_alloc0 (D.48817, 296);
    D.48818 = cfg->num_bblocks;
    D.49233 = D.48818;
    D.49234 = D.49233 + 1;
    cfg->num_bblocks = D.49234;
    D.49235 = (int) D.49233;
    falsebb->block_num = D.49235;
    D.49226 = ins->data.op[1].many_blocks;
    D.49227 = D.49226 + 8;
    *D.49227 = falsebb;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    D.49202 = falsebb->cil_code;
    if (D.49202 != 0B) goto <D.49236>; else goto <D.49237>;
    <D.49236>:
    D.48850 = cfg->cil_offset_to_bb;
    D.49202 = falsebb->cil_code;
    D.49205 = (long int) D.49202;
    D.48852 = cfg->cil_start;
    D.48853 = (long int) D.48852;
    D.49206 = D.49205 - D.48853;
    D.49207 = (long unsigned int) D.49206;
    D.49208 = D.49207 * 8;
    D.49209 = D.48850 + D.49208;
    *D.49209 = falsebb;
    <D.49237>:
    D.48858 = cfg->real_offset;
    falsebb->real_offset = D.48858;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.49241>; else goto <D.49238>;
    <D.49241>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48864 = D.48863 + 64985;
    if (D.48864 <= 9) goto <D.49239>; else goto <D.49242>;
    <D.49242>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48866 = D.48863 + 64878;
    if (D.48866 <= 9) goto <D.49239>; else goto <D.49243>;
    <D.49243>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48868 = D.48863 + 64888;
    if (D.48868 <= 9) goto <D.49239>; else goto <D.49238>;
    <D.49239>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48869 = D.48831->data.op[1].many_blocks;
    D.48870 = D.48869 + 8;
    D.48871 = *D.48870;
    if (D.48871 == 0B) goto <D.49244>; else goto <D.49238>;
    <D.49244>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48869 = D.48831->data.op[1].many_blocks;
    D.48870 = D.48869 + 8;
    *D.48870 = falsebb;
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    goto <D.49240>;
    <D.49238>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 == 0B) goto <D.49245>; else goto <D.49247>;
    <D.49247>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    if (D.48863 != 442) goto <D.49248>; else goto <D.49246>;
    <D.49248>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    if (D.48863 != 759) goto <D.49249>; else goto <D.49246>;
    <D.49249>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48864 = D.48863 + 64985;
    if (D.48864 > 9) goto <D.49250>; else goto <D.49246>;
    <D.49250>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48866 = D.48863 + 64878;
    if (D.48866 > 9) goto <D.49251>; else goto <D.49246>;
    <D.49251>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48863 = D.48831->opcode;
    D.48868 = D.48863 + 64888;
    if (D.48868 > 9) goto <D.49245>; else goto <D.49246>;
    <D.49245>:
    D.48830 = cfg->cbb;
    mono_link_bblock (cfg, D.48830, falsebb);
    <D.49246>:
    <D.49240>:
    D.48830 = cfg->cbb;
    D.48830->next_bb = falsebb;
    cfg->cbb = falsebb;
    goto <D.49252>;
    <D.49232>:
    D.48830 = cfg->cbb;
    D.48830->extended = 1;
    <D.49252>:
    <D.49224>:
  }
  D.49253 = no_proxy_bb->cil_code;
  if (D.49253 != 0B) goto <D.49254>; else goto <D.49255>;
  <D.49254>:
  D.48850 = cfg->cil_offset_to_bb;
  D.49253 = no_proxy_bb->cil_code;
  D.49256 = (long int) D.49253;
  D.48852 = cfg->cil_start;
  D.48853 = (long int) D.48852;
  D.49257 = D.49256 - D.48853;
  D.49258 = (long unsigned int) D.49257;
  D.49259 = D.49258 * 8;
  D.49260 = D.48850 + D.49259;
  *D.49260 = no_proxy_bb;
  <D.49255>:
  D.48858 = cfg->real_offset;
  no_proxy_bb->real_offset = D.48858;
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  if (D.48831 != 0B) goto <D.49264>; else goto <D.49261>;
  <D.49264>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48864 = D.48863 + 64985;
  if (D.48864 <= 9) goto <D.49262>; else goto <D.49265>;
  <D.49265>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48866 = D.48863 + 64878;
  if (D.48866 <= 9) goto <D.49262>; else goto <D.49266>;
  <D.49266>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48868 = D.48863 + 64888;
  if (D.48868 <= 9) goto <D.49262>; else goto <D.49261>;
  <D.49262>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48869 = D.48831->data.op[1].many_blocks;
  D.48870 = D.48869 + 8;
  D.48871 = *D.48870;
  if (D.48871 == 0B) goto <D.49267>; else goto <D.49261>;
  <D.49267>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48869 = D.48831->data.op[1].many_blocks;
  D.48870 = D.48869 + 8;
  *D.48870 = no_proxy_bb;
  D.48830 = cfg->cbb;
  mono_link_bblock (cfg, D.48830, no_proxy_bb);
  goto <D.49263>;
  <D.49261>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  if (D.48831 == 0B) goto <D.49268>; else goto <D.49270>;
  <D.49270>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  if (D.48863 != 442) goto <D.49271>; else goto <D.49269>;
  <D.49271>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  if (D.48863 != 759) goto <D.49272>; else goto <D.49269>;
  <D.49272>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48864 = D.48863 + 64985;
  if (D.48864 > 9) goto <D.49273>; else goto <D.49269>;
  <D.49273>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48866 = D.48863 + 64878;
  if (D.48866 > 9) goto <D.49274>; else goto <D.49269>;
  <D.49274>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48868 = D.48863 + 64888;
  if (D.48868 > 9) goto <D.49268>; else goto <D.49269>;
  <D.49268>:
  D.48830 = cfg->cbb;
  mono_link_bblock (cfg, D.48830, no_proxy_bb);
  <D.49269>:
  <D.49263>:
  D.48830 = cfg->cbb;
  D.48830->next_bb = no_proxy_bb;
  cfg->cbb = no_proxy_bb;
  mini_emit_castclass (cfg, obj_reg, klass_reg, klass, ok_result_bb);
  <D.49047>:
  D.49275 = ok_result_bb->cil_code;
  if (D.49275 != 0B) goto <D.49276>; else goto <D.49277>;
  <D.49276>:
  D.48850 = cfg->cil_offset_to_bb;
  D.49275 = ok_result_bb->cil_code;
  D.49278 = (long int) D.49275;
  D.48852 = cfg->cil_start;
  D.48853 = (long int) D.48852;
  D.49279 = D.49278 - D.48853;
  D.49280 = (long unsigned int) D.49279;
  D.49281 = D.49280 * 8;
  D.49282 = D.48850 + D.49281;
  *D.49282 = ok_result_bb;
  <D.49277>:
  D.48858 = cfg->real_offset;
  ok_result_bb->real_offset = D.48858;
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  if (D.48831 != 0B) goto <D.49286>; else goto <D.49283>;
  <D.49286>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48864 = D.48863 + 64985;
  if (D.48864 <= 9) goto <D.49284>; else goto <D.49287>;
  <D.49287>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48866 = D.48863 + 64878;
  if (D.48866 <= 9) goto <D.49284>; else goto <D.49288>;
  <D.49288>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48868 = D.48863 + 64888;
  if (D.48868 <= 9) goto <D.49284>; else goto <D.49283>;
  <D.49284>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48869 = D.48831->data.op[1].many_blocks;
  D.48870 = D.48869 + 8;
  D.48871 = *D.48870;
  if (D.48871 == 0B) goto <D.49289>; else goto <D.49283>;
  <D.49289>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48869 = D.48831->data.op[1].many_blocks;
  D.48870 = D.48869 + 8;
  *D.48870 = ok_result_bb;
  D.48830 = cfg->cbb;
  mono_link_bblock (cfg, D.48830, ok_result_bb);
  goto <D.49285>;
  <D.49283>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  if (D.48831 == 0B) goto <D.49290>; else goto <D.49292>;
  <D.49292>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  if (D.48863 != 442) goto <D.49293>; else goto <D.49291>;
  <D.49293>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  if (D.48863 != 759) goto <D.49294>; else goto <D.49291>;
  <D.49294>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48864 = D.48863 + 64985;
  if (D.48864 > 9) goto <D.49295>; else goto <D.49291>;
  <D.49295>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48866 = D.48863 + 64878;
  if (D.48866 > 9) goto <D.49296>; else goto <D.49291>;
  <D.49296>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48868 = D.48863 + 64888;
  if (D.48868 > 9) goto <D.49290>; else goto <D.49291>;
  <D.49290>:
  D.48830 = cfg->cbb;
  mono_link_bblock (cfg, D.48830, ok_result_bb);
  <D.49291>:
  <D.49285>:
  D.48830 = cfg->cbb;
  D.48830->next_bb = ok_result_bb;
  cfg->cbb = ok_result_bb;
  {
    struct MonoInst * inst;

    D.48817 = cfg->mempool;
    inst = mono_mempool_alloc (D.48817, 80);
    inst->data.op[1].const_val = 0;
    D.49297 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.49297;
    inst->prev = 0B;
    D.49298 = inst->prev;
    inst->next = D.49298;
    inst->opcode = 362;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.49299 = inst->sreg3;
    inst->sreg2 = D.49299;
    D.49300 = inst->sreg2;
    inst->sreg1 = D.49300;
    D.48829 = cfg->ip;
    inst->cil_code = D.48829;
    inst->dreg = dreg;
    inst->data.op[0].const_val = 0;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    if (D.48831 != 0B) goto <D.49301>; else goto <D.49302>;
    <D.49301>:
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    D.48831->next = inst;
    D.48830 = cfg->cbb;
    D.48831 = D.48830->last_ins;
    inst->prev = D.48831;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    goto <D.49303>;
    <D.49302>:
    D.48830 = cfg->cbb;
    D.48830 = cfg->cbb;
    D.48830->last_ins = inst;
    D.48831 = D.48830->last_ins;
    D.48830->code = D.48831;
    <D.49303>:
  }
  D.49304 = end_bb->cil_code;
  if (D.49304 != 0B) goto <D.49305>; else goto <D.49306>;
  <D.49305>:
  D.48850 = cfg->cil_offset_to_bb;
  D.49304 = end_bb->cil_code;
  D.49307 = (long int) D.49304;
  D.48852 = cfg->cil_start;
  D.48853 = (long int) D.48852;
  D.49308 = D.49307 - D.48853;
  D.49309 = (long unsigned int) D.49308;
  D.49310 = D.49309 * 8;
  D.49311 = D.48850 + D.49310;
  *D.49311 = end_bb;
  <D.49306>:
  D.48858 = cfg->real_offset;
  end_bb->real_offset = D.48858;
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  if (D.48831 != 0B) goto <D.49315>; else goto <D.49312>;
  <D.49315>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48864 = D.48863 + 64985;
  if (D.48864 <= 9) goto <D.49313>; else goto <D.49316>;
  <D.49316>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48866 = D.48863 + 64878;
  if (D.48866 <= 9) goto <D.49313>; else goto <D.49317>;
  <D.49317>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48868 = D.48863 + 64888;
  if (D.48868 <= 9) goto <D.49313>; else goto <D.49312>;
  <D.49313>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48869 = D.48831->data.op[1].many_blocks;
  D.48870 = D.48869 + 8;
  D.48871 = *D.48870;
  if (D.48871 == 0B) goto <D.49318>; else goto <D.49312>;
  <D.49318>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48869 = D.48831->data.op[1].many_blocks;
  D.48870 = D.48869 + 8;
  *D.48870 = end_bb;
  D.48830 = cfg->cbb;
  mono_link_bblock (cfg, D.48830, end_bb);
  goto <D.49314>;
  <D.49312>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  if (D.48831 == 0B) goto <D.49319>; else goto <D.49321>;
  <D.49321>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  if (D.48863 != 442) goto <D.49322>; else goto <D.49320>;
  <D.49322>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  if (D.48863 != 759) goto <D.49323>; else goto <D.49320>;
  <D.49323>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48864 = D.48863 + 64985;
  if (D.48864 > 9) goto <D.49324>; else goto <D.49320>;
  <D.49324>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48866 = D.48863 + 64878;
  if (D.48866 > 9) goto <D.49325>; else goto <D.49320>;
  <D.49325>:
  D.48830 = cfg->cbb;
  D.48831 = D.48830->last_ins;
  D.48863 = D.48831->opcode;
  D.48868 = D.48863 + 64888;
  if (D.48868 > 9) goto <D.49319>; else goto <D.49320>;
  <D.49319>:
  D.48830 = cfg->cbb;
  mono_link_bblock (cfg, D.48830, end_bb);
  <D.49320>:
  <D.49314>:
  D.48830 = cfg->cbb;
  D.48830->next_bb = end_bb;
  cfg->cbb = end_bb;
  D.48817 = cfg->mempool;
  ins = mono_mempool_alloc (D.48817, 80);
  ins->data.op[1].const_val = 0;
  D.49326 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.49326;
  ins->prev = 0B;
  D.49327 = ins->prev;
  ins->next = D.49327;
  ins->opcode = 362;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.49328 = ins->sreg3;
  ins->sreg2 = D.49328;
  D.49329 = ins->sreg2;
  ins->sreg1 = D.49329;
  D.48829 = cfg->ip;
  ins->cil_code = D.48829;
  ins->dreg = dreg;
  ins->type = 1;
  D.49330 = ins;
  return D.49330;
}


emit_memory_barrier (struct MonoCompile * cfg, int kind)
{
  struct MonoMemPool * D.49332;
  long int D.49333;
  struct MonoInst * D.49334;
  int D.49335;
  int D.49336;
  const unsigned char * D.49337;
  struct MonoBasicBlock * D.49338;
  struct MonoInst * D.49339;
  struct MonoInst * D.49343;
  struct MonoInst * ins;

  ins = 0B;
  D.49332 = cfg->mempool;
  ins = mono_mempool_alloc (D.49332, 80);
  ins->data.op[1].const_val = 0;
  D.49333 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.49333;
  ins->prev = 0B;
  D.49334 = ins->prev;
  ins->next = D.49334;
  ins->opcode = 813;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.49335 = ins->sreg3;
  ins->sreg2 = D.49335;
  D.49336 = ins->sreg2;
  ins->sreg1 = D.49336;
  D.49337 = cfg->ip;
  ins->cil_code = D.49337;
  D.49338 = cfg->cbb;
  D.49339 = D.49338->last_ins;
  if (D.49339 != 0B) goto <D.49340>; else goto <D.49341>;
  <D.49340>:
  D.49338 = cfg->cbb;
  D.49339 = D.49338->last_ins;
  D.49339->next = ins;
  D.49338 = cfg->cbb;
  D.49339 = D.49338->last_ins;
  ins->prev = D.49339;
  D.49338 = cfg->cbb;
  D.49338->last_ins = ins;
  goto <D.49342>;
  <D.49341>:
  D.49338 = cfg->cbb;
  D.49338 = cfg->cbb;
  D.49338->last_ins = ins;
  D.49339 = D.49338->last_ins;
  D.49338->code = D.49339;
  <D.49342>:
  ins->backend.memory_barrier_kind = kind;
  D.49343 = ins;
  return D.49343;
}


type_from_op (struct MonoInst * ins, struct MonoInst * src1, struct MonoInst * src2)
{
  short unsigned int D.49345;
  int D.49346;
  unsigned char D.49347;
  int D.49348;
  unsigned char D.49349;
  int D.49350;
  char D.49351;
  unsigned char D.49352;
  int D.49353;
  short unsigned int D.49354;
  short unsigned int D.49355;
  char D.49356;
  char D.49357;
  char D.49358;
  _Bool D.49359;
  unsigned char D.49360;
  char D.49370;
  _Bool D.49371;
  unsigned char D.49372;
  short unsigned int D.49378;
  short unsigned int D.49379;
  short unsigned int D.49380;
  short unsigned int D.49381;
  int D.49382;
  int D.49383;
  _Bool D.49384;
  unsigned char D.49385;
  char D.49386;
  short unsigned int D.49387;
  short unsigned int D.49388;
  unsigned char D.49389;
  short unsigned int D.49393;
  short unsigned int D.49394;
  short unsigned int D.49396;
  short unsigned int D.49397;
  short unsigned int D.49398;
  short unsigned int D.49399;
  short unsigned int D.49401;
  short unsigned int D.49402;
  struct MonoClass * D.49407;

  D.49345 = ins->opcode;
  D.49346 = (int) D.49345;
  switch (D.49346) <default: <D.25264>, case 59: <D.25187>, case 60: <D.25188>, case 61: <D.25189>, case 62: <D.25190>, case 63: <D.25191>, case 64: <D.25192>, case 65: <D.25193>, case 66: <D.25194>, case 67: <D.25195>, case 68: <D.25196>, case 88: <D.25169>, case 89: <D.25170>, case 90: <D.25171>, case 91: <D.25172>, case 92: <D.25175>, case 93: <D.25173>, case 94: <D.25176>, case 95: <D.25177>, case 96: <D.25178>, case 97: <D.25179>, case 98: <D.25180>, case 99: <D.25181>, case 100: <D.25182>, case 101: <D.25202>, case 102: <D.25203>, case 103: <D.25204>, case 104: <D.25205>, case 105: <D.25206>, case 106: <D.25234>, case 107: <D.25240>, case 108: <D.25241>, case 109: <D.25207>, case 110: <D.25235>, case 118: <D.25208>, case 130: <D.25221>, case 131: <D.25222>, case 132: <D.25223>, case 133: <D.25239>, case 134: <D.25224>, case 135: <D.25225>, case 136: <D.25226>, case 137: <D.25238>, case 138: <D.25219>, case 139: <D.25220>, case 179: <D.25213>, case 180: <D.25214>, case 181: <D.25215>, case 182: <D.25216>, case 183: <D.25217>, case 184: <D.25218>, case 185: <D.25236>, case 186: <D.25237>, case 209: <D.25243>, case 210: <D.25244>, case 211: <D.25245>, case 212: <D.25246>, case 213: <D.25247>, case 214: <D.25248>, case 215: <D.25249>, case 216: <D.25250>, case 217: <D.25251>, case 218: <D.25252>, case 219: <D.25253>, case 224: <D.25227>, case 322: <D.25183>, case 325: <D.25184>, case 326: <D.25185>, case 327: <D.25186>, case 388: <D.25254>, case 389: <D.25255>, case 390: <D.25256>, case 391: <D.25257>, case 392: <D.25258>, case 393: <D.25259>, case 394: <D.25260>, case 395: <D.25261>, case 396: <D.25262>, case 397: <D.25263>, case 446: <D.25197>, case 447: <D.25198>, case 448: <D.25199>, case 449: <D.25200>, case 450: <D.25201>, case 728: <D.25242>>
  <D.25169>:
  <D.25170>:
  <D.25171>:
  <D.25172>:
  <D.25173>:
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49349 = src2->type;
  D.49350 = (int) D.49349;
  D.49351 = bin_num_table[D.49348][D.49350];
  ins->type = D.49351;
  D.49345 = ins->opcode;
  D.49352 = ins->type;
  D.49353 = (int) D.49352;
  D.49354 = binops_op_map[D.49353];
  D.49355 = D.49345 + D.49354;
  ins->opcode = D.49355;
  goto <D.25174>;
  <D.25175>:
  <D.25176>:
  <D.25177>:
  <D.25178>:
  <D.25179>:
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49349 = src2->type;
  D.49350 = (int) D.49349;
  D.49356 = bin_int_table[D.49348][D.49350];
  ins->type = D.49356;
  D.49345 = ins->opcode;
  D.49352 = ins->type;
  D.49353 = (int) D.49352;
  D.49354 = binops_op_map[D.49353];
  D.49355 = D.49345 + D.49354;
  ins->opcode = D.49355;
  goto <D.25174>;
  <D.25180>:
  <D.25181>:
  <D.25182>:
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49349 = src2->type;
  D.49350 = (int) D.49349;
  D.49357 = shift_table[D.49348][D.49350];
  ins->type = D.49357;
  D.49345 = ins->opcode;
  D.49352 = ins->type;
  D.49353 = (int) D.49352;
  D.49354 = binops_op_map[D.49353];
  D.49355 = D.49345 + D.49354;
  ins->opcode = D.49355;
  goto <D.25174>;
  <D.25183>:
  <D.25184>:
  <D.25185>:
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49349 = src2->type;
  D.49350 = (int) D.49349;
  D.49358 = bin_comp_table[D.49348][D.49350];
  D.49359 = D.49358 != 0;
  D.49360 = (unsigned char) D.49359;
  ins->type = D.49360;
  D.49347 = src1->type;
  if (D.49347 == 2) goto <D.49361>; else goto <D.49364>;
  <D.49364>:
  D.49347 = src1->type;
  if (D.49347 == 3) goto <D.49361>; else goto <D.49365>;
  <D.49365>:
  D.49347 = src1->type;
  if (D.49347 == 6) goto <D.49361>; else goto <D.49366>;
  <D.49366>:
  D.49347 = src1->type;
  if (D.49347 == 5) goto <D.49361>; else goto <D.49362>;
  <D.49361>:
  ins->opcode = 325;
  goto <D.49363>;
  <D.49362>:
  D.49347 = src1->type;
  if (D.49347 == 4) goto <D.49367>; else goto <D.49368>;
  <D.49367>:
  ins->opcode = 324;
  goto <D.49369>;
  <D.49368>:
  ins->opcode = 326;
  <D.49369>:
  <D.49363>:
  goto <D.25174>;
  <D.25186>:
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49370 = bin_comp_table[D.49348][D.49348];
  D.49371 = D.49370 != 0;
  D.49372 = (unsigned char) D.49371;
  ins->type = D.49372;
  D.49347 = src1->type;
  if (D.49347 == 2) goto <D.49373>; else goto <D.49375>;
  <D.49375>:
  D.49347 = src1->type;
  if (D.49347 == 3) goto <D.49373>; else goto <D.49376>;
  <D.49376>:
  D.49347 = src1->type;
  if (D.49347 == 6) goto <D.49373>; else goto <D.49377>;
  <D.49377>:
  D.49347 = src1->type;
  if (D.49347 == 5) goto <D.49373>; else goto <D.49374>;
  <D.49373>:
  ins->opcode = 328;
  <D.49374>:
  goto <D.25174>;
  <D.25187>:
  <D.25188>:
  <D.25189>:
  <D.25190>:
  <D.25191>:
  <D.25192>:
  <D.25193>:
  <D.25194>:
  <D.25195>:
  <D.25196>:
  D.49345 = ins->opcode;
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49378 = beqops_op_map[D.49348];
  D.49379 = D.49345 + D.49378;
  ins->opcode = D.49379;
  goto <D.25174>;
  <D.25197>:
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49349 = src2->type;
  D.49350 = (int) D.49349;
  D.49358 = bin_comp_table[D.49348][D.49350];
  D.49359 = D.49358 != 0;
  D.49360 = (unsigned char) D.49359;
  ins->type = D.49360;
  D.49345 = ins->opcode;
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49380 = ceqops_op_map[D.49348];
  D.49381 = D.49345 + D.49380;
  ins->opcode = D.49381;
  goto <D.25174>;
  <D.25198>:
  <D.25199>:
  <D.25200>:
  <D.25201>:
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49349 = src2->type;
  D.49350 = (int) D.49349;
  D.49358 = bin_comp_table[D.49348][D.49350];
  D.49382 = (int) D.49358;
  D.49383 = D.49382 & 1;
  D.49384 = D.49383 != 0;
  D.49385 = (unsigned char) D.49384;
  ins->type = D.49385;
  D.49345 = ins->opcode;
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49380 = ceqops_op_map[D.49348];
  D.49381 = D.49345 + D.49380;
  ins->opcode = D.49381;
  goto <D.25174>;
  <D.25202>:
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49386 = neg_table[D.49348];
  ins->type = D.49386;
  D.49345 = ins->opcode;
  D.49352 = ins->type;
  D.49353 = (int) D.49352;
  D.49387 = unops_op_map[D.49353];
  D.49388 = D.49345 + D.49387;
  ins->opcode = D.49388;
  goto <D.25174>;
  <D.25203>:
  D.49347 = src1->type;
  D.49389 = D.49347 + 255;
  if (D.49389 <= 2) goto <D.49390>; else goto <D.49391>;
  <D.49390>:
  D.49347 = src1->type;
  ins->type = D.49347;
  goto <D.49392>;
  <D.49391>:
  ins->type = 0;
  <D.49392>:
  D.49345 = ins->opcode;
  D.49352 = ins->type;
  D.49353 = (int) D.49352;
  D.49387 = unops_op_map[D.49353];
  D.49388 = D.49345 + D.49387;
  ins->opcode = D.49388;
  goto <D.25174>;
  <D.25204>:
  <D.25205>:
  <D.25206>:
  <D.25207>:
  ins->type = 1;
  D.49345 = ins->opcode;
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49393 = unops_op_map[D.49348];
  D.49394 = D.49345 + D.49393;
  ins->opcode = D.49394;
  goto <D.25174>;
  <D.25208>:
  ins->type = 4;
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  switch (D.49348) <default: <D.49395>, case 1: <D.25209>, case 2: <D.25212>, case 3: <D.25210>>
  <D.25209>:
  <D.25210>:
  ins->opcode = 588;
  goto <D.25211>;
  <D.25212>:
  ins->opcode = 536;
  goto <D.25211>;
  <D.49395>:
  <D.25211>:
  goto <D.25174>;
  <D.25213>:
  <D.25214>:
  <D.25215>:
  <D.25216>:
  <D.25217>:
  <D.25218>:
  ins->type = 1;
  D.49345 = ins->opcode;
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49396 = ovf3ops_op_map[D.49348];
  D.49397 = D.49345 + D.49396;
  ins->opcode = D.49397;
  goto <D.25174>;
  <D.25219>:
  <D.25220>:
  ins->type = 3;
  D.49345 = ins->opcode;
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49398 = ovf2ops_op_map[D.49348];
  D.49399 = D.49345 + D.49398;
  ins->opcode = D.49399;
  goto <D.25174>;
  <D.25221>:
  <D.25222>:
  <D.25223>:
  <D.25224>:
  <D.25225>:
  <D.25226>:
  ins->type = 1;
  D.49345 = ins->opcode;
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49398 = ovf2ops_op_map[D.49348];
  D.49399 = D.49345 + D.49398;
  ins->opcode = D.49399;
  goto <D.25174>;
  <D.25227>:
  ins->type = 3;
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  switch (D.49348) <default: <D.49400>, case 1: <D.25228>, case 2: <D.25232>, case 3: <D.25230>, case 4: <D.25233>, case 5: <D.25231>>
  <D.25228>:
  ins->opcode = 589;
  goto <D.25229>;
  <D.25230>:
  <D.25231>:
  ins->opcode = 537;
  goto <D.25229>;
  <D.25232>:
  ins->opcode = 537;
  goto <D.25229>;
  <D.25233>:
  ins->opcode = 727;
  goto <D.25229>;
  <D.49400>:
  <D.25229>:
  goto <D.25174>;
  <D.25234>:
  <D.25235>:
  ins->type = 2;
  D.49345 = ins->opcode;
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49393 = unops_op_map[D.49348];
  D.49394 = D.49345 + D.49393;
  ins->opcode = D.49394;
  goto <D.25174>;
  <D.25236>:
  <D.25237>:
  ins->type = 2;
  D.49345 = ins->opcode;
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49396 = ovf3ops_op_map[D.49348];
  D.49397 = D.49345 + D.49396;
  ins->opcode = D.49397;
  goto <D.25174>;
  <D.25238>:
  <D.25239>:
  ins->type = 2;
  D.49345 = ins->opcode;
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49398 = ovf2ops_op_map[D.49348];
  D.49399 = D.49345 + D.49398;
  ins->opcode = D.49399;
  goto <D.25174>;
  <D.25240>:
  <D.25241>:
  ins->type = 4;
  D.49345 = ins->opcode;
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49393 = unops_op_map[D.49348];
  D.49394 = D.49345 + D.49393;
  ins->opcode = D.49394;
  goto <D.25174>;
  <D.25242>:
  ins->type = 4;
  goto <D.25174>;
  <D.25243>:
  <D.25244>:
  ins->type = 1;
  D.49345 = ins->opcode;
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49401 = ovfops_op_map[D.49348];
  D.49402 = D.49345 + D.49401;
  ins->opcode = D.49402;
  goto <D.25174>;
  <D.25245>:
  <D.25246>:
  <D.25247>:
  ins->type = 3;
  D.49345 = ins->opcode;
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49401 = ovfops_op_map[D.49348];
  D.49402 = D.49345 + D.49401;
  ins->opcode = D.49402;
  goto <D.25174>;
  <D.25248>:
  <D.25249>:
  <D.25250>:
  <D.25251>:
  <D.25252>:
  <D.25253>:
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49349 = src2->type;
  D.49350 = (int) D.49349;
  D.49351 = bin_num_table[D.49348][D.49350];
  ins->type = D.49351;
  D.49345 = ins->opcode;
  D.49347 = src1->type;
  D.49348 = (int) D.49347;
  D.49401 = ovfops_op_map[D.49348];
  D.49402 = D.49345 + D.49401;
  ins->opcode = D.49402;
  D.49352 = ins->type;
  if (D.49352 == 4) goto <D.49403>; else goto <D.49404>;
  <D.49403>:
  ins->type = 0;
  <D.49404>:
  goto <D.25174>;
  <D.25254>:
  ins->type = 3;
  goto <D.25174>;
  <D.25255>:
  <D.25256>:
  <D.25257>:
  <D.25258>:
  <D.25259>:
  <D.25260>:
  ins->type = 3;
  goto <D.25174>;
  <D.25261>:
  ins->type = 2;
  goto <D.25174>;
  <D.25262>:
  <D.25263>:
  ins->type = 4;
  goto <D.25174>;
  <D.25264>:
  D.49345 = ins->opcode;
  D.49346 = (int) D.49345;
  monoeg_g_log (0B, 4, "opcode 0x%04x not handled in type from op", D.49346);
  <D.25265>:
  goto <D.25265>;
  <D.25174>:
  D.49352 = ins->type;
  if (D.49352 == 5) goto <D.49405>; else goto <D.49406>;
  <D.49405>:
  D.49407 = mono_defaults.object_class;
  ins->klass = D.49407;
  <D.49406>:
}


mono_save_token_info (struct MonoCompile * cfg, struct MonoImage * image, guint32 token, void * key)
{
  long unsigned int D.49409;
  long unsigned int D.49410;
  struct MonoGenericContext * D.49413;
  unsigned int D.49416;
  struct MonoMemPool * D.49419;
  struct GHashTable * D.49420;

  D.49409 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.49410 = D.49409 & 33554432;
  if (D.49410 != 0) goto <D.49411>; else goto <D.49412>;
  <D.49411>:
  D.49413 = cfg->generic_context;
  if (D.49413 == 0B) goto <D.49414>; else goto <D.49415>;
  <D.49414>:
  D.49416 = token >> 24;
  if (D.49416 != 0) goto <D.49417>; else goto <D.49418>;
  <D.49417>:
  {
    struct MonoJumpInfoToken * jump_info_token;

    D.49419 = cfg->mempool;
    jump_info_token = mono_mempool_alloc0 (D.49419, 32);
    jump_info_token->image = image;
    jump_info_token->token = token;
    D.49420 = cfg->token_info_hash;
    monoeg_g_hash_table_insert_replace (D.49420, key, jump_info_token, 0);
  }
  <D.49418>:
  <D.49415>:
  <D.49412>:
}


ip_in_bb (struct MonoCompile * cfg, struct MonoBasicBlock * bb, const guint8 * ip)
{
  struct MonoBasicBlock * * D.49421;
  long int ip.433;
  unsigned char * D.49423;
  long int D.49424;
  long int D.49425;
  long unsigned int D.49426;
  long unsigned int D.49427;
  struct MonoBasicBlock * * D.49428;
  gboolean D.49429;
  int iftmp.434;
  struct MonoBasicBlock * b;

  D.49421 = cfg->cil_offset_to_bb;
  ip.433 = (long int) ip;
  D.49423 = cfg->cil_start;
  D.49424 = (long int) D.49423;
  D.49425 = ip.433 - D.49424;
  D.49426 = (long unsigned int) D.49425;
  D.49427 = D.49426 * 8;
  D.49428 = D.49421 + D.49427;
  b = *D.49428;
  if (b == 0B) goto <D.49431>; else goto <D.49434>;
  <D.49434>:
  if (b == bb) goto <D.49431>; else goto <D.49432>;
  <D.49431>:
  iftmp.434 = 1;
  goto <D.49433>;
  <D.49432>:
  iftmp.434 = 0;
  <D.49433>:
  D.49429 = iftmp.434;
  return D.49429;
}


__attribute__((__unused__))
handle_delegate_ctor (struct MonoCompile * cfg, struct MonoClass * klass, struct MonoInst * target, struct MonoMethod * method, int context_used)
{
  struct MonoInst * D.49438;
  short unsigned int D.49441;
  void * D.49443;
  struct MonoMemPool * D.49444;
  long int D.49445;
  struct MonoInst * D.49446;
  int D.49447;
  int D.49448;
  const unsigned char * D.49449;
  int D.49450;
  int D.49451;
  struct MonoBasicBlock * D.49452;
  struct MonoInst * D.49453;
  long unsigned int D.49457;
  long unsigned int D.49458;
  unsigned int D.49461;
  long int D.49462;
  struct MonoInst * D.49463;
  int D.49464;
  int D.49465;
  long int D.49469;
  struct MonoInst * D.49470;
  int D.49471;
  int D.49472;
  int D.49473;
  unsigned int D.49479;
  long unsigned int D.49483;
  long unsigned int D.49484;
  unsigned int D.49487;
  unsigned int D.49488;
  union mono_mutex_t * D.49494;
  _Bool D.49497;
  long int D.49498;
  long int D.49499;
  void * D.49502;
  struct GHashTable * D.49503;
  struct GHashTable * D.49506;
  _Bool D.49511;
  long int D.49512;
  long int D.49513;
  long unsigned int D.49516;
  long int D.49519;
  struct MonoInst * D.49520;
  guint16 iftmp.435;
  int D.49525;
  int D.49526;
  unsigned int D.49527;
  int D.49528;
  unsigned int D.49533;
  int D.49534;
  long int D.49538;
  struct MonoInst * D.49539;
  int D.49540;
  int D.49541;
  int D.49542;
  long int D.49548;
  struct MonoInst * D.49549;
  guint16 iftmp.436;
  int D.49554;
  int D.49555;
  unsigned int D.49556;
  int D.49557;
  struct MonoDomain * D.49562;
  unsigned int D.49563;
  int D.49564;
  long int D.49568;
  struct MonoInst * D.49569;
  int D.49570;
  int D.49571;
  int D.49572;
  struct MonoInst * ptr;
  int dreg;
  void * * trampoline;
  struct MonoInst * obj;
  struct MonoInst * method_ins;
  struct MonoInst * tramp_ins;
  struct MonoDomain * domain;
  guint8 * * code_slot;

  obj = handle_alloc (cfg, klass, 0, 0);
  if (obj == 0B) goto <D.49436>; else goto <D.49437>;
  <D.49436>:
  D.49438 = 0B;
  return D.49438;
  <D.49437>:
  D.49441 = target->opcode;
  if (D.49441 != 363) goto <D.49439>; else goto <D.49442>;
  <D.49442>:
  D.49443 = target->data.op[0].p;
  if (D.49443 != 0B) goto <D.49439>; else goto <D.49440>;
  <D.49439>:
  {
    struct MonoInst * inst;

    D.49444 = cfg->mempool;
    inst = mono_mempool_alloc (D.49444, 80);
    inst->data.op[1].const_val = 0;
    D.49445 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.49445;
    inst->prev = 0B;
    D.49446 = inst->prev;
    inst->next = D.49446;
    inst->opcode = 374;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.49447 = inst->sreg3;
    inst->sreg2 = D.49447;
    D.49448 = inst->sreg2;
    inst->sreg1 = D.49448;
    D.49449 = cfg->ip;
    inst->cil_code = D.49449;
    D.49450 = target->dreg;
    inst->sreg1 = D.49450;
    D.49451 = obj->dreg;
    inst->dreg = D.49451;
    inst->data.op[0].const_val = 32;
    D.49452 = cfg->cbb;
    D.49453 = D.49452->last_ins;
    if (D.49453 != 0B) goto <D.49454>; else goto <D.49455>;
    <D.49454>:
    D.49452 = cfg->cbb;
    D.49453 = D.49452->last_ins;
    D.49453->next = inst;
    D.49452 = cfg->cbb;
    D.49453 = D.49452->last_ins;
    inst->prev = D.49453;
    D.49452 = cfg->cbb;
    D.49452->last_ins = inst;
    goto <D.49456>;
    <D.49455>:
    D.49452 = cfg->cbb;
    D.49452 = cfg->cbb;
    D.49452->last_ins = inst;
    D.49453 = D.49452->last_ins;
    D.49452->code = D.49453;
    <D.49456>:
  }
  D.49457 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.49458 = D.49457 & 8;
  if (D.49458 != 0) goto <D.49459>; else goto <D.49460>;
  <D.49459>:
  D.49461 = alloc_preg (cfg);
  dreg = (int) D.49461;
  D.49444 = cfg->mempool;
  ptr = mono_mempool_alloc (D.49444, 80);
  ptr->data.op[1].const_val = 0;
  D.49462 = ptr->data.op[1].const_val;
  ptr->data.op[0].const_val = D.49462;
  ptr->prev = 0B;
  D.49463 = ptr->prev;
  ptr->next = D.49463;
  ptr->opcode = 538;
  ptr->flags = 0;
  ptr->type = 0;
  ptr->dreg = -1;
  ptr->sreg3 = -1;
  D.49464 = ptr->sreg3;
  ptr->sreg2 = D.49464;
  D.49465 = ptr->sreg2;
  ptr->sreg1 = D.49465;
  D.49449 = cfg->ip;
  ptr->cil_code = D.49449;
  ptr->dreg = dreg;
  D.49451 = obj->dreg;
  ptr->sreg1 = D.49451;
  ptr->data.op[1].const_val = 32;
  D.49452 = cfg->cbb;
  D.49453 = D.49452->last_ins;
  if (D.49453 != 0B) goto <D.49466>; else goto <D.49467>;
  <D.49466>:
  D.49452 = cfg->cbb;
  D.49453 = D.49452->last_ins;
  D.49453->next = ptr;
  D.49452 = cfg->cbb;
  D.49453 = D.49452->last_ins;
  ptr->prev = D.49453;
  D.49452 = cfg->cbb;
  D.49452->last_ins = ptr;
  goto <D.49468>;
  <D.49467>:
  D.49452 = cfg->cbb;
  D.49452 = cfg->cbb;
  D.49452->last_ins = ptr;
  D.49453 = D.49452->last_ins;
  D.49452->code = D.49453;
  <D.49468>:
  emit_write_barrier (cfg, ptr, target);
  <D.49460>:
  <D.49440>:
  method_ins = emit_get_rgctx_method (cfg, context_used, method, 5);
  {
    struct MonoInst * inst;

    D.49444 = cfg->mempool;
    inst = mono_mempool_alloc (D.49444, 80);
    inst->data.op[1].const_val = 0;
    D.49469 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.49469;
    inst->prev = 0B;
    D.49470 = inst->prev;
    inst->next = D.49470;
    inst->opcode = 374;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.49471 = inst->sreg3;
    inst->sreg2 = D.49471;
    D.49472 = inst->sreg2;
    inst->sreg1 = D.49472;
    D.49449 = cfg->ip;
    inst->cil_code = D.49449;
    D.49473 = method_ins->dreg;
    inst->sreg1 = D.49473;
    D.49451 = obj->dreg;
    inst->dreg = D.49451;
    inst->data.op[0].const_val = 40;
    D.49452 = cfg->cbb;
    D.49453 = D.49452->last_ins;
    if (D.49453 != 0B) goto <D.49474>; else goto <D.49475>;
    <D.49474>:
    D.49452 = cfg->cbb;
    D.49453 = D.49452->last_ins;
    D.49453->next = inst;
    D.49452 = cfg->cbb;
    D.49453 = D.49452->last_ins;
    inst->prev = D.49453;
    D.49452 = cfg->cbb;
    D.49452->last_ins = inst;
    goto <D.49476>;
    <D.49475>:
    D.49452 = cfg->cbb;
    D.49452 = cfg->cbb;
    D.49452->last_ins = inst;
    D.49453 = D.49452->last_ins;
    D.49452->code = D.49453;
    <D.49476>:
  }
  D.49457 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.49458 = D.49457 & 8;
  if (D.49458 != 0) goto <D.49477>; else goto <D.49478>;
  <D.49477>:
  D.49479 = alloc_preg (cfg);
  dreg = (int) D.49479;
  D.49444 = cfg->mempool;
  ptr = mono_mempool_alloc (D.49444, 80);
  ptr->data.op[1].const_val = 0;
  D.49462 = ptr->data.op[1].const_val;
  ptr->data.op[0].const_val = D.49462;
  ptr->prev = 0B;
  D.49463 = ptr->prev;
  ptr->next = D.49463;
  ptr->opcode = 538;
  ptr->flags = 0;
  ptr->type = 0;
  ptr->dreg = -1;
  ptr->sreg3 = -1;
  D.49464 = ptr->sreg3;
  ptr->sreg2 = D.49464;
  D.49465 = ptr->sreg2;
  ptr->sreg1 = D.49465;
  D.49449 = cfg->ip;
  ptr->cil_code = D.49449;
  ptr->dreg = dreg;
  D.49451 = obj->dreg;
  ptr->sreg1 = D.49451;
  ptr->data.op[1].const_val = 40;
  D.49452 = cfg->cbb;
  D.49453 = D.49452->last_ins;
  if (D.49453 != 0B) goto <D.49480>; else goto <D.49481>;
  <D.49480>:
  D.49452 = cfg->cbb;
  D.49453 = D.49452->last_ins;
  D.49453->next = ptr;
  D.49452 = cfg->cbb;
  D.49453 = D.49452->last_ins;
  ptr->prev = D.49453;
  D.49452 = cfg->cbb;
  D.49452->last_ins = ptr;
  goto <D.49482>;
  <D.49481>:
  D.49452 = cfg->cbb;
  D.49452 = cfg->cbb;
  D.49452->last_ins = ptr;
  D.49453 = D.49452->last_ins;
  D.49452->code = D.49453;
  <D.49482>:
  emit_write_barrier (cfg, ptr, method_ins);
  <D.49478>:
  D.49483 = BIT_FIELD_REF <*method, 64, 256>;
  D.49484 = D.49483 & 18014398509481984;
  if (D.49484 == 0) goto <D.49485>; else goto <D.49486>;
  <D.49485>:
  D.49487 = cfg->opt;
  D.49488 = D.49487 & 512;
  if (D.49488 == 0) goto <D.49489>; else goto <D.49490>;
  <D.49489>:
  {
    struct MonoInst * code_slot_ins;

    if (context_used != 0) goto <D.49491>; else goto <D.49492>;
    <D.49491>:
    code_slot_ins = emit_get_rgctx_method (cfg, context_used, method, 11);
    goto <D.49493>;
    <D.49492>:
    domain = mono_domain_get ();
    {
      int ret;

      D.49494 = &domain->lock.mutex;
      ret = pthread_mutex_lock (D.49494);
      if (ret != 0) goto <D.49495>; else goto <D.49496>;
      <D.49495>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.49496>:
      D.49497 = ret != 0;
      D.49498 = (long int) D.49497;
      D.49499 = __builtin_expect (D.49498, 0);
      if (D.49499 != 0) goto <D.49500>; else goto <D.49501>;
      <D.49500>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4431, "ret == 0");
      <D.49501>:
    }
    D.49502 = domain->runtime_info;
    D.49503 = MEM[(struct MonoJitDomainInfo *)D.49502].method_code_hash;
    if (D.49503 == 0B) goto <D.49504>; else goto <D.49505>;
    <D.49504>:
    D.49502 = domain->runtime_info;
    D.49506 = monoeg_g_hash_table_new (0B, 0B);
    MEM[(struct MonoJitDomainInfo *)D.49502].method_code_hash = D.49506;
    <D.49505>:
    D.49502 = domain->runtime_info;
    D.49503 = MEM[(struct MonoJitDomainInfo *)D.49502].method_code_hash;
    code_slot = monoeg_g_hash_table_lookup (D.49503, method);
    if (code_slot == 0B) goto <D.49507>; else goto <D.49508>;
    <D.49507>:
    code_slot = mono_domain_alloc0 (domain, 8);
    D.49502 = domain->runtime_info;
    D.49503 = MEM[(struct MonoJitDomainInfo *)D.49502].method_code_hash;
    monoeg_g_hash_table_insert_replace (D.49503, method, code_slot, 0);
    <D.49508>:
    {
      int ret;

      D.49494 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.49494);
      if (ret != 0) goto <D.49509>; else goto <D.49510>;
      <D.49509>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.49510>:
      D.49511 = ret != 0;
      D.49512 = (long int) D.49511;
      D.49513 = __builtin_expect (D.49512, 0);
      if (D.49513 != 0) goto <D.49514>; else goto <D.49515>;
      <D.49514>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 4439, "ret == 0");
      <D.49515>:
    }
    D.49457 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.49516 = D.49457 & 33554432;
    if (D.49516 != 0) goto <D.49517>; else goto <D.49518>;
    <D.49517>:
    D.49444 = cfg->mempool;
    code_slot_ins = mono_mempool_alloc (D.49444, 80);
    code_slot_ins->data.op[1].const_val = 0;
    D.49519 = code_slot_ins->data.op[1].const_val;
    code_slot_ins->data.op[0].const_val = D.49519;
    code_slot_ins->prev = 0B;
    D.49520 = code_slot_ins->prev;
    code_slot_ins->next = D.49520;
    D.49457 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.49516 = D.49457 & 33554432;
    if (D.49516 != 0) goto <D.49522>; else goto <D.49523>;
    <D.49522>:
    iftmp.435 = 732;
    goto <D.49524>;
    <D.49523>:
    iftmp.435 = 363;
    <D.49524>:
    code_slot_ins->opcode = iftmp.435;
    code_slot_ins->flags = 0;
    code_slot_ins->type = 0;
    code_slot_ins->dreg = -1;
    code_slot_ins->sreg3 = -1;
    D.49525 = code_slot_ins->sreg3;
    code_slot_ins->sreg2 = D.49525;
    D.49526 = code_slot_ins->sreg2;
    code_slot_ins->sreg1 = D.49526;
    D.49449 = cfg->ip;
    code_slot_ins->cil_code = D.49449;
    code_slot_ins->data.op[0].p = method;
    code_slot_ins->data.op[1].src = 50B;
    code_slot_ins->type = 3;
    D.49527 = alloc_dreg (cfg, 3);
    D.49528 = (int) D.49527;
    code_slot_ins->dreg = D.49528;
    D.49452 = cfg->cbb;
    D.49453 = D.49452->last_ins;
    if (D.49453 != 0B) goto <D.49529>; else goto <D.49530>;
    <D.49529>:
    D.49452 = cfg->cbb;
    D.49453 = D.49452->last_ins;
    D.49453->next = code_slot_ins;
    D.49452 = cfg->cbb;
    D.49453 = D.49452->last_ins;
    code_slot_ins->prev = D.49453;
    D.49452 = cfg->cbb;
    D.49452->last_ins = code_slot_ins;
    goto <D.49531>;
    <D.49530>:
    D.49452 = cfg->cbb;
    D.49452 = cfg->cbb;
    D.49452->last_ins = code_slot_ins;
    D.49453 = D.49452->last_ins;
    D.49452->code = D.49453;
    <D.49531>:
    goto <D.49532>;
    <D.49518>:
    D.49444 = cfg->mempool;
    code_slot_ins = mono_mempool_alloc (D.49444, 80);
    code_slot_ins->data.op[1].const_val = 0;
    D.49519 = code_slot_ins->data.op[1].const_val;
    code_slot_ins->data.op[0].const_val = D.49519;
    code_slot_ins->prev = 0B;
    D.49520 = code_slot_ins->prev;
    code_slot_ins->next = D.49520;
    code_slot_ins->opcode = 363;
    code_slot_ins->flags = 0;
    code_slot_ins->type = 0;
    code_slot_ins->dreg = -1;
    code_slot_ins->sreg3 = -1;
    D.49525 = code_slot_ins->sreg3;
    code_slot_ins->sreg2 = D.49525;
    D.49526 = code_slot_ins->sreg2;
    code_slot_ins->sreg1 = D.49526;
    D.49449 = cfg->ip;
    code_slot_ins->cil_code = D.49449;
    code_slot_ins->data.op[0].p = code_slot;
    code_slot_ins->type = 3;
    D.49533 = alloc_dreg (cfg, 3);
    D.49534 = (int) D.49533;
    code_slot_ins->dreg = D.49534;
    D.49452 = cfg->cbb;
    D.49453 = D.49452->last_ins;
    if (D.49453 != 0B) goto <D.49535>; else goto <D.49536>;
    <D.49535>:
    D.49452 = cfg->cbb;
    D.49453 = D.49452->last_ins;
    D.49453->next = code_slot_ins;
    D.49452 = cfg->cbb;
    D.49453 = D.49452->last_ins;
    code_slot_ins->prev = D.49453;
    D.49452 = cfg->cbb;
    D.49452->last_ins = code_slot_ins;
    goto <D.49537>;
    <D.49536>:
    D.49452 = cfg->cbb;
    D.49452 = cfg->cbb;
    D.49452->last_ins = code_slot_ins;
    D.49453 = D.49452->last_ins;
    D.49452->code = D.49453;
    <D.49537>:
    <D.49532>:
    <D.49493>:
    {
      struct MonoInst * inst;

      D.49444 = cfg->mempool;
      inst = mono_mempool_alloc (D.49444, 80);
      inst->data.op[1].const_val = 0;
      D.49538 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.49538;
      inst->prev = 0B;
      D.49539 = inst->prev;
      inst->next = D.49539;
      inst->opcode = 374;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.49540 = inst->sreg3;
      inst->sreg2 = D.49540;
      D.49541 = inst->sreg2;
      inst->sreg1 = D.49541;
      D.49449 = cfg->ip;
      inst->cil_code = D.49449;
      D.49542 = code_slot_ins->dreg;
      inst->sreg1 = D.49542;
      D.49451 = obj->dreg;
      inst->dreg = D.49451;
      inst->data.op[0].const_val = 56;
      D.49452 = cfg->cbb;
      D.49453 = D.49452->last_ins;
      if (D.49453 != 0B) goto <D.49543>; else goto <D.49544>;
      <D.49543>:
      D.49452 = cfg->cbb;
      D.49453 = D.49452->last_ins;
      D.49453->next = inst;
      D.49452 = cfg->cbb;
      D.49453 = D.49452->last_ins;
      inst->prev = D.49453;
      D.49452 = cfg->cbb;
      D.49452->last_ins = inst;
      goto <D.49545>;
      <D.49544>:
      D.49452 = cfg->cbb;
      D.49452 = cfg->cbb;
      D.49452->last_ins = inst;
      D.49453 = D.49452->last_ins;
      D.49452->code = D.49453;
      <D.49545>:
    }
  }
  <D.49490>:
  <D.49486>:
  D.49457 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.49516 = D.49457 & 33554432;
  if (D.49516 != 0) goto <D.49546>; else goto <D.49547>;
  <D.49546>:
  D.49444 = cfg->mempool;
  tramp_ins = mono_mempool_alloc (D.49444, 80);
  tramp_ins->data.op[1].const_val = 0;
  D.49548 = tramp_ins->data.op[1].const_val;
  tramp_ins->data.op[0].const_val = D.49548;
  tramp_ins->prev = 0B;
  D.49549 = tramp_ins->prev;
  tramp_ins->next = D.49549;
  D.49457 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.49516 = D.49457 & 33554432;
  if (D.49516 != 0) goto <D.49551>; else goto <D.49552>;
  <D.49551>:
  iftmp.436 = 732;
  goto <D.49553>;
  <D.49552>:
  iftmp.436 = 363;
  <D.49553>:
  tramp_ins->opcode = iftmp.436;
  tramp_ins->flags = 0;
  tramp_ins->type = 0;
  tramp_ins->dreg = -1;
  tramp_ins->sreg3 = -1;
  D.49554 = tramp_ins->sreg3;
  tramp_ins->sreg2 = D.49554;
  D.49555 = tramp_ins->sreg2;
  tramp_ins->sreg1 = D.49555;
  D.49449 = cfg->ip;
  tramp_ins->cil_code = D.49449;
  tramp_ins->data.op[0].p = klass;
  tramp_ins->data.op[1].src = 30B;
  tramp_ins->type = 3;
  D.49556 = alloc_dreg (cfg, 3);
  D.49557 = (int) D.49556;
  tramp_ins->dreg = D.49557;
  D.49452 = cfg->cbb;
  D.49453 = D.49452->last_ins;
  if (D.49453 != 0B) goto <D.49558>; else goto <D.49559>;
  <D.49558>:
  D.49452 = cfg->cbb;
  D.49453 = D.49452->last_ins;
  D.49453->next = tramp_ins;
  D.49452 = cfg->cbb;
  D.49453 = D.49452->last_ins;
  tramp_ins->prev = D.49453;
  D.49452 = cfg->cbb;
  D.49452->last_ins = tramp_ins;
  goto <D.49560>;
  <D.49559>:
  D.49452 = cfg->cbb;
  D.49452 = cfg->cbb;
  D.49452->last_ins = tramp_ins;
  D.49453 = D.49452->last_ins;
  D.49452->code = D.49453;
  <D.49560>:
  goto <D.49561>;
  <D.49547>:
  D.49562 = cfg->domain;
  trampoline = mono_create_delegate_trampoline (D.49562, klass);
  D.49444 = cfg->mempool;
  tramp_ins = mono_mempool_alloc (D.49444, 80);
  tramp_ins->data.op[1].const_val = 0;
  D.49548 = tramp_ins->data.op[1].const_val;
  tramp_ins->data.op[0].const_val = D.49548;
  tramp_ins->prev = 0B;
  D.49549 = tramp_ins->prev;
  tramp_ins->next = D.49549;
  tramp_ins->opcode = 363;
  tramp_ins->flags = 0;
  tramp_ins->type = 0;
  tramp_ins->dreg = -1;
  tramp_ins->sreg3 = -1;
  D.49554 = tramp_ins->sreg3;
  tramp_ins->sreg2 = D.49554;
  D.49555 = tramp_ins->sreg2;
  tramp_ins->sreg1 = D.49555;
  D.49449 = cfg->ip;
  tramp_ins->cil_code = D.49449;
  tramp_ins->data.op[0].p = trampoline;
  tramp_ins->type = 3;
  D.49563 = alloc_dreg (cfg, 3);
  D.49564 = (int) D.49563;
  tramp_ins->dreg = D.49564;
  D.49452 = cfg->cbb;
  D.49453 = D.49452->last_ins;
  if (D.49453 != 0B) goto <D.49565>; else goto <D.49566>;
  <D.49565>:
  D.49452 = cfg->cbb;
  D.49453 = D.49452->last_ins;
  D.49453->next = tramp_ins;
  D.49452 = cfg->cbb;
  D.49453 = D.49452->last_ins;
  tramp_ins->prev = D.49453;
  D.49452 = cfg->cbb;
  D.49452->last_ins = tramp_ins;
  goto <D.49567>;
  <D.49566>:
  D.49452 = cfg->cbb;
  D.49452 = cfg->cbb;
  D.49452->last_ins = tramp_ins;
  D.49453 = D.49452->last_ins;
  D.49452->code = D.49453;
  <D.49567>:
  <D.49561>:
  {
    struct MonoInst * inst;

    D.49444 = cfg->mempool;
    inst = mono_mempool_alloc (D.49444, 80);
    inst->data.op[1].const_val = 0;
    D.49568 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.49568;
    inst->prev = 0B;
    D.49569 = inst->prev;
    inst->next = D.49569;
    inst->opcode = 374;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.49570 = inst->sreg3;
    inst->sreg2 = D.49570;
    D.49571 = inst->sreg2;
    inst->sreg1 = D.49571;
    D.49449 = cfg->ip;
    inst->cil_code = D.49449;
    D.49572 = tramp_ins->dreg;
    inst->sreg1 = D.49572;
    D.49451 = obj->dreg;
    inst->dreg = D.49451;
    inst->data.op[0].const_val = 24;
    D.49452 = cfg->cbb;
    D.49453 = D.49452->last_ins;
    if (D.49453 != 0B) goto <D.49573>; else goto <D.49574>;
    <D.49573>:
    D.49452 = cfg->cbb;
    D.49453 = D.49452->last_ins;
    D.49453->next = inst;
    D.49452 = cfg->cbb;
    D.49453 = D.49452->last_ins;
    inst->prev = D.49453;
    D.49452 = cfg->cbb;
    D.49452->last_ins = inst;
    goto <D.49575>;
    <D.49574>:
    D.49452 = cfg->cbb;
    D.49452 = cfg->cbb;
    D.49452->last_ins = inst;
    D.49453 = D.49452->last_ins;
    D.49452->code = D.49453;
    <D.49575>:
  }
  D.49438 = obj;
  return D.49438;
}


mini_get_method (struct MonoCompile * cfg, struct MonoMethod * m, guint32 token, struct MonoClass * klass, struct MonoGenericContext * context)
{
  struct MonoGenericSharingContext * D.49581;
  struct MonoClass * D.49584;
  struct MonoType * D.49585;
  int D.49586;
  struct MonoMethod * D.49589;
  struct MonoMethod * method;

  method = mini_get_method_allow_open (m, token, klass, context);
  if (method != 0B) goto <D.49577>; else goto <D.49578>;
  <D.49577>:
  if (cfg != 0B) goto <D.49579>; else goto <D.49580>;
  <D.49579>:
  D.49581 = cfg->generic_sharing_context;
  if (D.49581 == 0B) goto <D.49582>; else goto <D.49583>;
  <D.49582>:
  D.49584 = method->klass;
  D.49585 = &D.49584->byval_arg;
  D.49586 = mono_class_is_open_constructed_type (D.49585);
  if (D.49586 != 0) goto <D.49587>; else goto <D.49588>;
  <D.49587>:
  D.49589 = 0B;
  return D.49589;
  <D.49588>:
  <D.49583>:
  <D.49580>:
  <D.49578>:
  D.49589 = method;
  return D.49589;
}


check_linkdemand (struct MonoCompile * cfg, struct MonoMethod * caller, struct MonoMethod * callee)
{
  struct MonoMethod * D.49591;
  unsigned char D.49594;
  gboolean D.49597;
  struct MonoDomain * D.49598;
  struct MonoMemPool * D.49603;
  void * D.49604;
  struct MonoInst * D.49605;
  long int D.49606;
  struct MonoInst * D.49607;
  int D.49608;
  int D.49609;
  const unsigned char * D.49610;
  unsigned int D.49611;
  int D.49612;
  void * D.49613;
  struct MonoInst * D.49614;
  long int D.49615;
  struct MonoInst * D.49616;
  guint16 iftmp.437;
  long unsigned int D.49618;
  long unsigned int D.49619;
  int D.49623;
  int D.49624;
  unsigned int D.49625;
  int D.49626;
  struct MonoMethod * D.49627;
  unsigned int D.49629;
  guint32 result;

  D.49591 = cfg->method;
  if (D.49591 != caller) goto <D.49592>; else goto <D.49593>;
  <D.49592>:
  D.49594 = mono_method_has_declsec (callee);
  if (D.49594 != 0) goto <D.49595>; else goto <D.49596>;
  <D.49595>:
  D.49597 = 1;
  return D.49597;
  <D.49596>:
  <D.49593>:
  D.49598 = cfg->domain;
  result = mono_declsec_linkdemand (D.49598, caller, callee);
  if (result == 0) goto <D.49599>; else goto <D.49600>;
  <D.49599>:
  D.49597 = 0;
  return D.49597;
  <D.49600>:
  if (result == 4) goto <D.49601>; else goto <D.49602>;
  <D.49601>:
  {
    struct MonoSecurityManager * secman;
    struct MonoInst * args[2];

    try
      {
        secman = mono_security_manager_get_methods ();
        D.49603 = cfg->mempool;
        D.49604 = mono_mempool_alloc (D.49603, 80);
        args[0] = D.49604;
        D.49605 = args[0];
        D.49605 = args[0];
        D.49605->data.op[1].const_val = 0;
        D.49606 = D.49605->data.op[1].const_val;
        D.49605->data.op[0].const_val = D.49606;
        D.49605 = args[0];
        D.49605 = args[0];
        D.49605->prev = 0B;
        D.49607 = D.49605->prev;
        D.49605->next = D.49607;
        D.49605 = args[0];
        D.49605->opcode = 362;
        D.49605 = args[0];
        D.49605->flags = 0;
        D.49605 = args[0];
        D.49605->type = 0;
        D.49605 = args[0];
        D.49605->dreg = -1;
        D.49605 = args[0];
        D.49605 = args[0];
        D.49605 = args[0];
        D.49605->sreg3 = -1;
        D.49608 = D.49605->sreg3;
        D.49605->sreg2 = D.49608;
        D.49609 = D.49605->sreg2;
        D.49605->sreg1 = D.49609;
        D.49605 = args[0];
        D.49610 = cfg->ip;
        D.49605->cil_code = D.49610;
        D.49605 = args[0];
        D.49605->data.op[0].const_val = 4;
        D.49605 = args[0];
        D.49605->type = 1;
        D.49605 = args[0];
        D.49611 = alloc_dreg (cfg, 1);
        D.49612 = (int) D.49611;
        D.49605->dreg = D.49612;
        D.49603 = cfg->mempool;
        D.49613 = mono_mempool_alloc (D.49603, 80);
        args[1] = D.49613;
        D.49614 = args[1];
        D.49614 = args[1];
        D.49614->data.op[1].const_val = 0;
        D.49615 = D.49614->data.op[1].const_val;
        D.49614->data.op[0].const_val = D.49615;
        D.49614 = args[1];
        D.49614 = args[1];
        D.49614->prev = 0B;
        D.49616 = D.49614->prev;
        D.49614->next = D.49616;
        D.49614 = args[1];
        D.49618 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.49619 = D.49618 & 33554432;
        if (D.49619 != 0) goto <D.49620>; else goto <D.49621>;
        <D.49620>:
        iftmp.437 = 732;
        goto <D.49622>;
        <D.49621>:
        iftmp.437 = 363;
        <D.49622>:
        D.49614->opcode = iftmp.437;
        D.49614 = args[1];
        D.49614->flags = 0;
        D.49614 = args[1];
        D.49614->type = 0;
        D.49614 = args[1];
        D.49614->dreg = -1;
        D.49614 = args[1];
        D.49614 = args[1];
        D.49614 = args[1];
        D.49614->sreg3 = -1;
        D.49623 = D.49614->sreg3;
        D.49614->sreg2 = D.49623;
        D.49624 = D.49614->sreg2;
        D.49614->sreg1 = D.49624;
        D.49614 = args[1];
        D.49610 = cfg->ip;
        D.49614->cil_code = D.49610;
        D.49614 = args[1];
        D.49614->data.op[0].p = caller;
        D.49614 = args[1];
        D.49614->data.op[1].src = 6B;
        D.49614 = args[1];
        D.49614->type = 3;
        D.49614 = args[1];
        D.49625 = alloc_dreg (cfg, 3);
        D.49626 = (int) D.49625;
        D.49614->dreg = D.49626;
        D.49627 = secman->linkdemandsecurityexception;
        mono_emit_method_call (cfg, D.49627, &args, 0B);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
  goto <D.49628>;
  <D.49602>:
  D.49629 = cfg->exception_type;
  if (D.49629 == 0) goto <D.49630>; else goto <D.49631>;
  <D.49630>:
  mono_cfg_set_exception (cfg, 1);
  cfg->exception_data = result;
  D.49597 = 1;
  return D.49597;
  <D.49631>:
  <D.49628>:
  D.49597 = 0;
  return D.49597;
}


ensure_method_is_allowed_to_call_method (struct MonoCompile * cfg, struct MonoMethod * caller, struct MonoMethod * callee, struct MonoBasicBlock * bblock, unsigned char * ip)
{
  struct MonoMethod * D.49633;
  struct MonoException * ex;

  D.49633 = get_original_method (caller);
  ex = mono_security_core_clr_is_call_allowed (D.49633, callee);
  if (ex != 0B) goto <D.49634>; else goto <D.49635>;
  <D.49634>:
  emit_throw_exception (cfg, ex);
  <D.49635>:
}


emit_optimized_ldloca_ir (struct MonoCompile * cfg, unsigned char * ip, unsigned char * end, int size)
{
  unsigned char * D.49638;
  unsigned char D.49639;
  unsigned char * D.49641;
  short unsigned int D.49642;
  short unsigned int D.49643;
  int D.49644;
  int D.49645;
  int D.49646;
  int D.49647;
  unsigned char * D.49648;
  unsigned char D.49651;
  struct MonoBasicBlock * D.49656;
  int D.49657;
  unsigned int D.49660;
  unsigned int D.49661;
  unsigned int D.49662;
  unsigned int D.49663;
  unsigned int D.49664;
  unsigned int D.49665;
  unsigned int D.49666;
  unsigned int D.49667;
  unsigned int D.49668;
  unsigned int D.49669;
  struct MonoMethod * D.49670;
  unsigned int token.438;
  struct MonoGenericContext * D.49672;
  unsigned char D.49676;
  struct MonoDebugOptions * D.49677;
  int D.49678;
  struct MonoType * D.49680;
  unsigned char * D.49681;
  int local;
  int token;
  struct MonoClass * klass;
  struct MonoType * type;
  void load_error = <<< error >>>;

  if (size == 1) goto <D.49636>; else goto <D.49637>;
  <D.49636>:
  D.49638 = ip + 1;
  D.49639 = *D.49638;
  local = (int) D.49639;
  ip = ip + 2;
  goto <D.49640>;
  <D.49637>:
  D.49641 = ip + 2;
  D.49642 = MEM[(const guint16 *)D.49641];
  D.49643 = D.49642 >> 8;
  D.49644 = (int) D.49643;
  D.49641 = ip + 2;
  D.49642 = MEM[(const guint16 *)D.49641];
  D.49645 = (int) D.49642;
  D.49646 = D.49645 << 8;
  D.49647 = D.49646 & 65535;
  local = D.49644 | D.49647;
  ip = ip + 4;
  <D.49640>:
  D.49648 = ip + 6;
  if (D.49648 < end) goto <D.49649>; else goto <D.49650>;
  <D.49649>:
  D.49651 = *ip;
  if (D.49651 == 254) goto <D.49652>; else goto <D.49653>;
  <D.49652>:
  D.49638 = ip + 1;
  D.49639 = *D.49638;
  if (D.49639 == 21) goto <D.49654>; else goto <D.49655>;
  <D.49654>:
  D.49656 = cfg->cbb;
  D.49638 = ip + 1;
  D.49657 = ip_in_bb (cfg, D.49656, D.49638);
  if (D.49657 != 0) goto <D.49658>; else goto <D.49659>;
  <D.49658>:
  D.49641 = ip + 2;
  D.49660 = MEM[(const guint32 *)D.49641];
  D.49661 = D.49660 << 24;
  D.49641 = ip + 2;
  D.49660 = MEM[(const guint32 *)D.49641];
  D.49662 = D.49660 >> 8;
  D.49663 = D.49662 & 65280;
  D.49664 = D.49661 | D.49663;
  D.49641 = ip + 2;
  D.49660 = MEM[(const guint32 *)D.49641];
  D.49665 = D.49660 << 8;
  D.49666 = D.49665 & 16711680;
  D.49667 = D.49664 | D.49666;
  D.49641 = ip + 2;
  D.49660 = MEM[(const guint32 *)D.49641];
  D.49668 = D.49660 >> 24;
  D.49669 = D.49667 | D.49668;
  token = (int) D.49669;
  D.49670 = cfg->current_method;
  token.438 = (unsigned int) token;
  D.49672 = cfg->generic_context;
  klass = mini_get_class (D.49670, token.438, D.49672);
  if (klass == 0B) goto <D.49673>; else goto <D.49675>;
  <D.49675>:
  D.49676 = klass->exception_type;
  if (D.49676 != 0) goto <D.49673>; else goto <D.49674>;
  <D.49673>:
  cfg->exception_ptr = klass;
  D.49677 = mini_get_debug_options ();
  D.49678 = D.49677->break_on_unverified;
  if (D.49678 != 0) goto <D.49679>; else goto load_error;
  <D.49679>:
  raise (5);
  <D.49674>:
  D.49680 = &klass->byval_arg;
  type = mini_replace_type (D.49680);
  emit_init_local (cfg, local, type);
  D.49681 = ip + 6;
  return D.49681;
  <D.49659>:
  <D.49655>:
  <D.49653>:
  <D.49650>:
  load_error:
  D.49681 = 0B;
  return D.49681;
}


target_type_is_incompatible (struct MonoCompile * cfg, struct MonoType * target, struct MonoInst * arg)
{
  long unsigned int D.49683;
  long unsigned int D.49684;
  unsigned char D.49687;
  int D.49690;
  struct MonoClass * D.49691;
  struct MonoClass * D.49692;
  _Bool D.49693;
  unsigned char D.49696;
  int D.49697;
  int D.49728;
  struct MonoGenericSharingContext * D.49737;
  _Bool D.49738;
  long int D.49739;
  long int D.49740;
  int D.49743;
  struct MonoType * simple_type;
  struct MonoClass * klass;

  target = mini_replace_type (target);
  D.49683 = BIT_FIELD_REF <*target, 64, 64>;
  D.49684 = D.49683 & 8589934592;
  if (D.49684 != 0) goto <D.49685>; else goto <D.49686>;
  <D.49685>:
  D.49687 = arg->type;
  if (D.49687 == 5) goto <D.49688>; else goto <D.49689>;
  <D.49688>:
  D.49691 = arg->klass;
  D.49692 = mono_class_from_mono_type (target);
  D.49693 = D.49691 != D.49692;
  D.49690 = (int) D.49693;
  return D.49690;
  <D.49689>:
  D.49687 = arg->type;
  if (D.49687 == 3) goto <D.49694>; else goto <D.49695>;
  <D.49694>:
  D.49690 = 0;
  return D.49690;
  <D.49695>:
  D.49690 = 1;
  return D.49690;
  <D.49686>:
  simple_type = mono_type_get_underlying_type (target);
  D.49696 = simple_type->type;
  D.49697 = (int) D.49696;
  switch (D.49697) <default: <D.25775>, case 1: <D.25748>, case 2: <D.25751>, case 3: <D.25754>, case 4: <D.25749>, case 5: <D.25750>, case 6: <D.25752>, case 7: <D.25753>, case 8: <D.25755>, case 9: <D.25756>, case 10: <D.25766>, case 11: <D.25767>, case 12: <D.25768>, case 13: <D.25769>, case 14: <D.25762>, case 15: <D.25757>, case 17: <D.25770>, case 18: <D.25761>, case 19: <D.25773>, case 20: <D.25765>, case 21: <D.25772>, case 22: <D.25771>, case 24: <D.25758>, case 25: <D.25759>, case 27: <D.25760>, case 28: <D.25763>, case 29: <D.25764>, case 30: <D.25774>>
  <D.25748>:
  D.49690 = 1;
  return D.49690;
  <D.25749>:
  <D.25750>:
  <D.25751>:
  <D.25752>:
  <D.25753>:
  <D.25754>:
  <D.25755>:
  <D.25756>:
  D.49687 = arg->type;
  if (D.49687 != 1) goto <D.49698>; else goto <D.49699>;
  <D.49698>:
  D.49687 = arg->type;
  if (D.49687 != 3) goto <D.49700>; else goto <D.49701>;
  <D.49700>:
  D.49690 = 1;
  return D.49690;
  <D.49701>:
  <D.49699>:
  D.49690 = 0;
  return D.49690;
  <D.25757>:
  D.49687 = arg->type;
  if (D.49687 != 1) goto <D.49702>; else goto <D.49703>;
  <D.49702>:
  D.49687 = arg->type;
  if (D.49687 != 3) goto <D.49704>; else goto <D.49705>;
  <D.49704>:
  D.49687 = arg->type;
  if (D.49687 != 5) goto <D.49706>; else goto <D.49707>;
  <D.49706>:
  D.49690 = 1;
  return D.49690;
  <D.49707>:
  <D.49705>:
  <D.49703>:
  D.49690 = 0;
  return D.49690;
  <D.25758>:
  <D.25759>:
  <D.25760>:
  D.49687 = arg->type;
  if (D.49687 != 1) goto <D.49708>; else goto <D.49709>;
  <D.49708>:
  D.49687 = arg->type;
  if (D.49687 != 3) goto <D.49710>; else goto <D.49711>;
  <D.49710>:
  D.49687 = arg->type;
  if (D.49687 != 5) goto <D.49712>; else goto <D.49713>;
  <D.49712>:
  D.49690 = 1;
  return D.49690;
  <D.49713>:
  <D.49711>:
  <D.49709>:
  D.49690 = 0;
  return D.49690;
  <D.25761>:
  <D.25762>:
  <D.25763>:
  <D.25764>:
  <D.25765>:
  D.49687 = arg->type;
  if (D.49687 != 6) goto <D.49714>; else goto <D.49715>;
  <D.49714>:
  D.49690 = 1;
  return D.49690;
  <D.49715>:
  D.49690 = 0;
  return D.49690;
  <D.25766>:
  <D.25767>:
  D.49687 = arg->type;
  if (D.49687 != 2) goto <D.49716>; else goto <D.49717>;
  <D.49716>:
  D.49690 = 1;
  return D.49690;
  <D.49717>:
  D.49690 = 0;
  return D.49690;
  <D.25768>:
  <D.25769>:
  D.49687 = arg->type;
  if (D.49687 != 4) goto <D.49718>; else goto <D.49719>;
  <D.49718>:
  D.49690 = 1;
  return D.49690;
  <D.49719>:
  D.49690 = 0;
  return D.49690;
  <D.25770>:
  D.49687 = arg->type;
  if (D.49687 != 7) goto <D.49720>; else goto <D.49721>;
  <D.49720>:
  D.49690 = 1;
  return D.49690;
  <D.49721>:
  klass = mono_class_from_mono_type (simple_type);
  D.49691 = arg->klass;
  if (D.49691 != klass) goto <D.49722>; else goto <D.49723>;
  <D.49722>:
  D.49690 = 1;
  return D.49690;
  <D.49723>:
  D.49690 = 0;
  return D.49690;
  <D.25771>:
  D.49687 = arg->type;
  if (D.49687 != 7) goto <D.49724>; else goto <D.49725>;
  <D.49724>:
  D.49690 = 1;
  return D.49690;
  <D.49725>:
  klass = mono_class_from_mono_type (simple_type);
  D.49691 = arg->klass;
  if (D.49691 != klass) goto <D.49726>; else goto <D.49727>;
  <D.49726>:
  D.49690 = 1;
  return D.49690;
  <D.49727>:
  D.49690 = 0;
  return D.49690;
  <D.25772>:
  D.49728 = mono_type_generic_inst_is_valuetype (simple_type);
  if (D.49728 != 0) goto <D.49729>; else goto <D.49730>;
  <D.49729>:
  D.49687 = arg->type;
  if (D.49687 != 7) goto <D.49731>; else goto <D.49732>;
  <D.49731>:
  D.49690 = 1;
  return D.49690;
  <D.49732>:
  klass = mono_class_from_mono_type (simple_type);
  D.49691 = arg->klass;
  if (D.49691 != klass) goto <D.49733>; else goto <D.49734>;
  <D.49733>:
  D.49690 = 1;
  return D.49690;
  <D.49734>:
  D.49690 = 0;
  return D.49690;
  <D.49730>:
  D.49687 = arg->type;
  if (D.49687 != 6) goto <D.49735>; else goto <D.49736>;
  <D.49735>:
  D.49690 = 1;
  return D.49690;
  <D.49736>:
  D.49690 = 0;
  return D.49690;
  <D.25773>:
  <D.25774>:
  D.49737 = cfg->generic_sharing_context;
  D.49738 = D.49737 == 0B;
  D.49739 = (long int) D.49738;
  D.49740 = __builtin_expect (D.49739, 0);
  if (D.49740 != 0) goto <D.49741>; else goto <D.49742>;
  <D.49741>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 2160, "cfg->generic_sharing_context");
  <D.49742>:
  D.49743 = mini_type_var_is_vt (cfg, simple_type);
  if (D.49743 != 0) goto <D.49744>; else goto <D.49745>;
  <D.49744>:
  D.49687 = arg->type;
  if (D.49687 != 7) goto <D.49746>; else goto <D.49747>;
  <D.49746>:
  D.49690 = 1;
  return D.49690;
  <D.49747>:
  goto <D.49748>;
  <D.49745>:
  D.49687 = arg->type;
  if (D.49687 != 6) goto <D.49749>; else goto <D.49750>;
  <D.49749>:
  D.49690 = 1;
  return D.49690;
  <D.49750>:
  <D.49748>:
  D.49690 = 0;
  return D.49690;
  <D.25775>:
  D.49696 = simple_type->type;
  D.49697 = (int) D.49696;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in target_type_is_incompatible", D.49697);
  <D.25776>:
  goto <D.25776>;
  D.49690 = 1;
  return D.49690;
}


emit_stloc_ir (struct MonoCompile * cfg, struct MonoInst * * sp, struct MonoMethodHeader * header, int n)
{
  struct MonoType * D.49752;
  struct MonoBasicBlock * D.49756;
  struct MonoInst * D.49757;
  struct MonoInst * D.49758;
  short unsigned int D.49760;
  short unsigned int D.49761;
  struct MonoInst * * D.49763;
  long unsigned int D.49764;
  long unsigned int D.49765;
  struct MonoInst * * D.49766;
  struct MonoInst * D.49767;
  int D.49768;
  struct MonoMemPool * D.49769;
  long int D.49770;
  struct MonoInst * D.49771;
  int D.49772;
  int D.49773;
  const unsigned char * D.49774;
  struct MonoType * D.49775;
  unsigned int D.49776;
  short unsigned int D.49777;
  struct MonoClass * D.49778;
  int D.49779;
  short unsigned int D.49780;
  struct MonoClass * D.49783;
  struct MonoInst * ins;
  guint32 opcode;

  D.49752 = header->locals[n];
  opcode = mono_type_to_regmove (cfg, D.49752);
  if (opcode == 424) goto <D.49755>; else goto <D.49753>;
  <D.49755>:
  D.49756 = cfg->cbb;
  D.49757 = D.49756->last_ins;
  D.49758 = *sp;
  if (D.49757 == D.49758) goto <D.49759>; else goto <D.49753>;
  <D.49759>:
  D.49758 = *sp;
  D.49760 = D.49758->opcode;
  D.49761 = D.49760 + 65174;
  if (D.49761 <= 1) goto <D.49762>; else goto <D.49753>;
  <D.49762>:
  D.49758 = *sp;
  D.49763 = cfg->locals;
  D.49764 = (long unsigned int) n;
  D.49765 = D.49764 * 8;
  D.49766 = D.49763 + D.49765;
  D.49767 = *D.49766;
  D.49768 = D.49767->dreg;
  D.49758->dreg = D.49768;
  goto <D.49754>;
  <D.49753>:
  D.49769 = cfg->mempool;
  ins = mono_mempool_alloc (D.49769, 80);
  ins->data.op[1].const_val = 0;
  D.49770 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.49770;
  ins->prev = 0B;
  D.49771 = ins->prev;
  ins->next = D.49771;
  ins->opcode = 424;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.49772 = ins->sreg3;
  ins->sreg2 = D.49772;
  D.49773 = ins->sreg2;
  ins->sreg1 = D.49773;
  D.49774 = cfg->ip;
  ins->cil_code = D.49774;
  D.49763 = cfg->locals;
  D.49764 = (long unsigned int) n;
  D.49765 = D.49764 * 8;
  D.49766 = D.49763 + D.49765;
  D.49767 = *D.49766;
  D.49775 = D.49767->data.op[1].vtype;
  D.49776 = mono_type_to_regmove (cfg, D.49775);
  D.49777 = (short unsigned int) D.49776;
  ins->opcode = D.49777;
  D.49763 = cfg->locals;
  D.49764 = (long unsigned int) n;
  D.49765 = D.49764 * 8;
  D.49766 = D.49763 + D.49765;
  D.49767 = *D.49766;
  D.49778 = D.49767->klass;
  ins->klass = D.49778;
  D.49758 = *sp;
  D.49779 = D.49758->dreg;
  ins->sreg1 = D.49779;
  D.49763 = cfg->locals;
  D.49764 = (long unsigned int) n;
  D.49765 = D.49764 * 8;
  D.49766 = D.49763 + D.49765;
  D.49767 = *D.49766;
  D.49768 = D.49767->dreg;
  ins->dreg = D.49768;
  D.49780 = ins->opcode;
  if (D.49780 == 427) goto <D.49781>; else goto <D.49782>;
  <D.49781>:
  D.49763 = cfg->locals;
  D.49764 = (long unsigned int) n;
  D.49765 = D.49764 * 8;
  D.49766 = D.49763 + D.49765;
  D.49767 = *D.49766;
  D.49775 = D.49767->data.op[1].vtype;
  D.49783 = mono_class_from_mono_type (D.49775);
  ins->klass = D.49783;
  <D.49782>:
  D.49756 = cfg->cbb;
  D.49757 = D.49756->last_ins;
  if (D.49757 != 0B) goto <D.49784>; else goto <D.49785>;
  <D.49784>:
  D.49756 = cfg->cbb;
  D.49757 = D.49756->last_ins;
  D.49757->next = ins;
  D.49756 = cfg->cbb;
  D.49757 = D.49756->last_ins;
  ins->prev = D.49757;
  D.49756 = cfg->cbb;
  D.49756->last_ins = ins;
  goto <D.49786>;
  <D.49785>:
  D.49756 = cfg->cbb;
  D.49756 = cfg->cbb;
  D.49756->last_ins = ins;
  D.49757 = D.49756->last_ins;
  D.49756->code = D.49757;
  <D.49786>:
  <D.49754>:
}


generic_class_is_reference_type (struct MonoCompile * cfg, struct MonoClass * klass)
{
  gboolean D.49787;
  struct MonoType * D.49788;

  D.49788 = &klass->byval_arg;
  D.49787 = mini_type_is_reference (cfg, D.49788);
  return D.49787;
}


mini_get_class (struct MonoMethod * method, guint32 token, struct MonoGenericContext * context)
{
  long unsigned int D.49790;
  long unsigned int D.49791;
  struct MonoClass * D.49797;
  struct MonoImage * D.49798;
  struct MonoClass * D.49801;
  struct MonoClass * klass;

  D.49790 = BIT_FIELD_REF <*method, 64, 256>;
  D.49791 = D.49790 & 4467570830351532032;
  if (D.49791 != 0) goto <D.49792>; else goto <D.49793>;
  <D.49792>:
  klass = mono_method_get_wrapper_data (method, token);
  if (context != 0B) goto <D.49794>; else goto <D.49795>;
  <D.49794>:
  klass = mono_class_inflate_generic_class (klass, context);
  <D.49795>:
  goto <D.49796>;
  <D.49793>:
  D.49797 = method->klass;
  D.49798 = D.49797->image;
  klass = mono_class_get_full (D.49798, token, context);
  <D.49796>:
  if (klass != 0B) goto <D.49799>; else goto <D.49800>;
  <D.49799>:
  mono_class_init (klass);
  <D.49800>:
  D.49801 = klass;
  return D.49801;
}


handle_gsharedvt_ldaddr (struct MonoCompile * cfg)
{
  struct MonoMemPool * D.49803;
  long int D.49804;
  struct MonoInst * D.49805;
  int D.49806;
  int D.49807;
  const unsigned char * D.49808;
  struct MonoInst * D.49809;
  int D.49810;
  struct MonoBasicBlock * D.49811;
  struct MonoInst * D.49812;
  struct MonoInst * D.49816;
  int D.49817;
  struct MonoInst * use;

  D.49803 = cfg->mempool;
  use = mono_mempool_alloc (D.49803, 80);
  use->data.op[1].const_val = 0;
  D.49804 = use->data.op[1].const_val;
  use->data.op[0].const_val = D.49804;
  use->prev = 0B;
  D.49805 = use->prev;
  use->next = D.49805;
  use->opcode = 796;
  use->flags = 0;
  use->type = 0;
  use->dreg = -1;
  use->sreg3 = -1;
  D.49806 = use->sreg3;
  use->sreg2 = D.49806;
  D.49807 = use->sreg2;
  use->sreg1 = D.49807;
  D.49808 = cfg->ip;
  use->cil_code = D.49808;
  D.49809 = cfg->gsharedvt_info_var;
  D.49810 = D.49809->dreg;
  use->sreg1 = D.49810;
  D.49811 = cfg->cbb;
  D.49812 = D.49811->last_ins;
  if (D.49812 != 0B) goto <D.49813>; else goto <D.49814>;
  <D.49813>:
  D.49811 = cfg->cbb;
  D.49812 = D.49811->last_ins;
  D.49812->next = use;
  D.49811 = cfg->cbb;
  D.49812 = D.49811->last_ins;
  use->prev = D.49812;
  D.49811 = cfg->cbb;
  D.49811->last_ins = use;
  goto <D.49815>;
  <D.49814>:
  D.49811 = cfg->cbb;
  D.49811 = cfg->cbb;
  D.49811->last_ins = use;
  D.49812 = D.49811->last_ins;
  D.49811->code = D.49812;
  <D.49815>:
  D.49803 = cfg->mempool;
  use = mono_mempool_alloc (D.49803, 80);
  use->data.op[1].const_val = 0;
  D.49804 = use->data.op[1].const_val;
  use->data.op[0].const_val = D.49804;
  use->prev = 0B;
  D.49805 = use->prev;
  use->next = D.49805;
  use->opcode = 796;
  use->flags = 0;
  use->type = 0;
  use->dreg = -1;
  use->sreg3 = -1;
  D.49806 = use->sreg3;
  use->sreg2 = D.49806;
  D.49807 = use->sreg2;
  use->sreg1 = D.49807;
  D.49808 = cfg->ip;
  use->cil_code = D.49808;
  D.49816 = cfg->gsharedvt_locals_var;
  D.49817 = D.49816->dreg;
  use->sreg1 = D.49817;
  D.49811 = cfg->cbb;
  D.49812 = D.49811->last_ins;
  if (D.49812 != 0B) goto <D.49818>; else goto <D.49819>;
  <D.49818>:
  D.49811 = cfg->cbb;
  D.49812 = D.49811->last_ins;
  D.49812->next = use;
  D.49811 = cfg->cbb;
  D.49812 = D.49811->last_ins;
  use->prev = D.49812;
  D.49811 = cfg->cbb;
  D.49811->last_ins = use;
  goto <D.49820>;
  <D.49819>:
  D.49811 = cfg->cbb;
  D.49811 = cfg->cbb;
  D.49811->last_ins = use;
  D.49812 = D.49811->last_ins;
  D.49811->code = D.49812;
  <D.49820>:
}


mono_emit_load_got_addr (struct MonoCompile * cfg)
{
  struct MonoInst * D.49823;
  long unsigned int D.49825;
  long unsigned int D.49826;
  struct MonoMemPool * D.49827;
  long int D.49828;
  struct MonoInst * D.49829;
  int D.49830;
  int D.49831;
  const unsigned char * D.49832;
  struct MonoMethodHeader * D.49833;
  const unsigned char * D.49834;
  int D.49835;
  struct MonoBasicBlock * D.49836;
  struct MonoInst * D.49837;
  struct MonoInst * D.49841;
  long int D.49845;
  struct MonoInst * D.49846;
  int D.49847;
  int D.49848;
  struct MonoBasicBlock * D.49849;
  struct MonoInst * D.49850;
  struct MonoInst * getaddr;
  struct MonoInst * dummy_use;

  D.49823 = cfg->got_var;
  if (D.49823 == 0B) goto <D.49821>; else goto <D.49824>;
  <D.49824>:
  D.49825 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.49826 = D.49825 & 4194304;
  if (D.49826 != 0) goto <D.49821>; else goto <D.49822>;
  <D.49821>:
  return;
  <D.49822>:
  D.49827 = cfg->mempool;
  getaddr = mono_mempool_alloc (D.49827, 80);
  getaddr->data.op[1].const_val = 0;
  D.49828 = getaddr->data.op[1].const_val;
  getaddr->data.op[0].const_val = D.49828;
  getaddr->prev = 0B;
  D.49829 = getaddr->prev;
  getaddr->next = D.49829;
  getaddr->opcode = 795;
  getaddr->flags = 0;
  getaddr->type = 0;
  getaddr->dreg = -1;
  getaddr->sreg3 = -1;
  D.49830 = getaddr->sreg3;
  getaddr->sreg2 = D.49830;
  D.49831 = getaddr->sreg2;
  getaddr->sreg1 = D.49831;
  D.49832 = cfg->ip;
  getaddr->cil_code = D.49832;
  D.49833 = cfg->header;
  D.49834 = D.49833->code;
  getaddr->cil_code = D.49834;
  D.49823 = cfg->got_var;
  D.49835 = D.49823->dreg;
  getaddr->dreg = D.49835;
  D.49836 = cfg->bb_entry;
  D.49837 = D.49836->code;
  if (D.49837 != 0B) goto <D.49838>; else goto <D.49839>;
  <D.49838>:
  D.49836 = cfg->bb_entry;
  D.49837 = D.49836->code;
  getaddr->next = D.49837;
  D.49836 = cfg->bb_entry;
  D.49836->code = getaddr;
  goto <D.49840>;
  <D.49839>:
  D.49836 = cfg->bb_entry;
  D.49841 = D.49836->last_ins;
  if (D.49841 != 0B) goto <D.49842>; else goto <D.49843>;
  <D.49842>:
  D.49836 = cfg->bb_entry;
  D.49841 = D.49836->last_ins;
  D.49841->next = getaddr;
  D.49836 = cfg->bb_entry;
  D.49841 = D.49836->last_ins;
  getaddr->prev = D.49841;
  D.49836 = cfg->bb_entry;
  D.49836->last_ins = getaddr;
  goto <D.49844>;
  <D.49843>:
  D.49836 = cfg->bb_entry;
  D.49836 = cfg->bb_entry;
  D.49836->last_ins = getaddr;
  D.49841 = D.49836->last_ins;
  D.49836->code = D.49841;
  <D.49844>:
  <D.49840>:
  cfg->got_var_allocated = 1;
  D.49827 = cfg->mempool;
  dummy_use = mono_mempool_alloc (D.49827, 80);
  dummy_use->data.op[1].const_val = 0;
  D.49845 = dummy_use->data.op[1].const_val;
  dummy_use->data.op[0].const_val = D.49845;
  dummy_use->prev = 0B;
  D.49846 = dummy_use->prev;
  dummy_use->next = D.49846;
  dummy_use->opcode = 796;
  dummy_use->flags = 0;
  dummy_use->type = 0;
  dummy_use->dreg = -1;
  dummy_use->sreg3 = -1;
  D.49847 = dummy_use->sreg3;
  dummy_use->sreg2 = D.49847;
  D.49848 = dummy_use->sreg2;
  dummy_use->sreg1 = D.49848;
  D.49832 = cfg->ip;
  dummy_use->cil_code = D.49832;
  D.49823 = cfg->got_var;
  D.49835 = D.49823->dreg;
  dummy_use->sreg1 = D.49835;
  D.49849 = cfg->bb_exit;
  D.49850 = D.49849->last_ins;
  if (D.49850 != 0B) goto <D.49851>; else goto <D.49852>;
  <D.49851>:
  D.49849 = cfg->bb_exit;
  D.49850 = D.49849->last_ins;
  D.49850->next = dummy_use;
  D.49849 = cfg->bb_exit;
  D.49850 = D.49849->last_ins;
  dummy_use->prev = D.49850;
  D.49849 = cfg->bb_exit;
  D.49849->last_ins = dummy_use;
  goto <D.49853>;
  <D.49852>:
  D.49849 = cfg->bb_exit;
  D.49849 = cfg->bb_exit;
  D.49849->last_ins = dummy_use;
  D.49850 = D.49849->last_ins;
  D.49849->code = D.49850;
  <D.49853>:
}


emit_init_local (struct MonoCompile * cfg, int local, struct MonoType * type)
{
  struct MonoInst * * D.49855;
  long unsigned int D.49856;
  long unsigned int D.49857;
  struct MonoInst * * D.49858;
  unsigned char D.49861;
  <unnamed type> D.49862;
  unsigned int D.49863;
  struct MonoMemPool * D.49864;
  long int D.49865;
  struct MonoInst * D.49866;
  int D.49867;
  int D.49868;
  const unsigned char * D.49869;
  struct MonoInst * D.49870;
  struct MonoType * D.49871;
  unsigned int D.49872;
  short unsigned int D.49873;
  struct MonoClass * D.49874;
  struct MonoBasicBlock * D.49875;
  struct MonoInst * D.49876;
  int D.49877;
  int D.49878;
  short unsigned int D.49879;
  struct MonoClass * D.49882;
  int D.49887;
  struct MonoInst * var;

  D.49855 = cfg->locals;
  D.49856 = (long unsigned int) local;
  D.49857 = D.49856 * 8;
  D.49858 = D.49855 + D.49857;
  var = *D.49858;
  if (0 != 0) goto <D.49859>; else goto <D.49860>;
  <D.49859>:
  {
    struct MonoInst * store;
    int reg;

    D.49861 = var->type;
    D.49862 = (<unnamed type>) D.49861;
    D.49863 = alloc_dreg (cfg, D.49862);
    reg = (int) D.49863;
    emit_init_rvar (cfg, reg, type);
    D.49864 = cfg->mempool;
    store = mono_mempool_alloc (D.49864, 80);
    store->data.op[1].const_val = 0;
    D.49865 = store->data.op[1].const_val;
    store->data.op[0].const_val = D.49865;
    store->prev = 0B;
    D.49866 = store->prev;
    store->next = D.49866;
    store->opcode = 424;
    store->flags = 0;
    store->type = 0;
    store->dreg = -1;
    store->sreg3 = -1;
    D.49867 = store->sreg3;
    store->sreg2 = D.49867;
    D.49868 = store->sreg2;
    store->sreg1 = D.49868;
    D.49869 = cfg->ip;
    store->cil_code = D.49869;
    D.49855 = cfg->locals;
    D.49856 = (long unsigned int) local;
    D.49857 = D.49856 * 8;
    D.49858 = D.49855 + D.49857;
    D.49870 = *D.49858;
    D.49871 = D.49870->data.op[1].vtype;
    D.49872 = mono_type_to_regmove (cfg, D.49871);
    D.49873 = (short unsigned int) D.49872;
    store->opcode = D.49873;
    D.49855 = cfg->locals;
    D.49856 = (long unsigned int) local;
    D.49857 = D.49856 * 8;
    D.49858 = D.49855 + D.49857;
    D.49870 = *D.49858;
    D.49874 = D.49870->klass;
    store->klass = D.49874;
    D.49875 = cfg->cbb;
    D.49876 = D.49875->last_ins;
    D.49877 = D.49876->dreg;
    store->sreg1 = D.49877;
    D.49855 = cfg->locals;
    D.49856 = (long unsigned int) local;
    D.49857 = D.49856 * 8;
    D.49858 = D.49855 + D.49857;
    D.49870 = *D.49858;
    D.49878 = D.49870->dreg;
    store->dreg = D.49878;
    D.49879 = store->opcode;
    if (D.49879 == 427) goto <D.49880>; else goto <D.49881>;
    <D.49880>:
    D.49855 = cfg->locals;
    D.49856 = (long unsigned int) local;
    D.49857 = D.49856 * 8;
    D.49858 = D.49855 + D.49857;
    D.49870 = *D.49858;
    D.49871 = D.49870->data.op[1].vtype;
    D.49882 = mono_class_from_mono_type (D.49871);
    store->klass = D.49882;
    <D.49881>:
    D.49875 = cfg->cbb;
    D.49876 = D.49875->last_ins;
    if (D.49876 != 0B) goto <D.49883>; else goto <D.49884>;
    <D.49883>:
    D.49875 = cfg->cbb;
    D.49876 = D.49875->last_ins;
    D.49876->next = store;
    D.49875 = cfg->cbb;
    D.49876 = D.49875->last_ins;
    store->prev = D.49876;
    D.49875 = cfg->cbb;
    D.49875->last_ins = store;
    goto <D.49885>;
    <D.49884>:
    D.49875 = cfg->cbb;
    D.49875 = cfg->cbb;
    D.49875->last_ins = store;
    D.49876 = D.49875->last_ins;
    D.49875->code = D.49876;
    <D.49885>:
  }
  goto <D.49886>;
  <D.49860>:
  D.49887 = var->dreg;
  emit_init_rvar (cfg, D.49887, type);
  <D.49886>:
}


emit_push_lmf (struct MonoCompile * cfg)
{
  long unsigned int D.49888;
  long unsigned int D.49889;
  long unsigned int D.49894;
  int D.49896;
  _Bool D.49898;
  long int D.49899;
  long int D.49900;
  struct MonoBasicBlock * D.49903;
  struct MonoInst * D.49904;
  struct MonoMemPool * D.49908;
  long int D.49909;
  struct MonoInst * D.49910;
  int D.49911;
  int D.49912;
  const unsigned char * D.49913;
  struct MonoInst * D.49914;
  unsigned char D.49915;
  unsigned char D.49916;
  struct MonoClass * D.49917;
  unsigned int D.49918;
  int D.49919;
  int D.49920;
  _Bool D.49921;
  long int D.49922;
  long int D.49923;
  struct MonoType * D.49926;
  int D.49927;
  struct MonoInst * iftmp.439;
  int D.49933;
  int D.49934;
  unsigned int D.49935;
  unsigned int D.49936;
  struct MonoInst * * D.49939;
  sizetype D.49940;
  sizetype D.49941;
  sizetype D.49942;
  struct MonoInst * * D.49943;
  struct MonoInst * iftmp.440;
  int D.49946;
  unsigned int D.49947;
  sizetype D.49950;
  sizetype D.49951;
  struct MonoInst * * D.49952;
  _Bool D.49954;
  long int D.49955;
  long int D.49956;
  _Bool D.49959;
  long int D.49960;
  long int D.49961;
  unsigned char D.49964;
  unsigned char D.49965;
  unsigned char D.49966;
  unsigned char D.49967;
  int D.49971;
  struct MonoInst * D.49975;
  struct MonoClass * D.49978;
  struct MonoType * D.49979;
  struct MonoInst * D.49980;
  int D.49987;
  unsigned int D.49988;
  int D.49989;
  int D.49992;
  struct MonoInst * iftmp.441;
  struct MonoInst * iftmp.442;
  _Bool D.50005;
  long int D.50006;
  long int D.50007;
  _Bool D.50010;
  long int D.50011;
  long int D.50012;
  unsigned char D.50015;
  unsigned char D.50016;
  unsigned char D.50017;
  unsigned char D.50018;
  unsigned int D.50022;
  int lmf_reg;
  int prev_lmf_reg;
  struct MonoInst * ins;
  struct MonoInst * lmf_ins;

  D.49888 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.49889 = D.49888 & 32;
  if (D.49889 == 0) goto <D.49890>; else goto <D.49891>;
  <D.49890>:
  return;
  <D.49891>:
  D.49888 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.49894 = D.49888 & 16;
  if (D.49894 != 0) goto <D.49895>; else goto <D.49892>;
  <D.49895>:
  D.49896 = mini_tls_get_supported (cfg, 3);
  if (D.49896 != 0) goto <D.49897>; else goto <D.49892>;
  <D.49897>:
  lmf_ins = mono_get_lmf_intrinsic (cfg);
  D.49898 = lmf_ins == 0B;
  D.49899 = (long int) D.49898;
  D.49900 = __builtin_expect (D.49899, 0);
  if (D.49900 != 0) goto <D.49901>; else goto <D.49902>;
  <D.49901>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1922, "lmf_ins");
  <D.49902>:
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  if (D.49904 != 0B) goto <D.49905>; else goto <D.49906>;
  <D.49905>:
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  D.49904->next = lmf_ins;
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  lmf_ins->prev = D.49904;
  D.49903 = cfg->cbb;
  D.49903->last_ins = lmf_ins;
  goto <D.49907>;
  <D.49906>:
  D.49903 = cfg->cbb;
  D.49903 = cfg->cbb;
  D.49903->last_ins = lmf_ins;
  D.49904 = D.49903->last_ins;
  D.49903->code = D.49904;
  <D.49907>:
  D.49908 = cfg->mempool;
  ins = mono_mempool_alloc (D.49908, 80);
  ins->data.op[1].const_val = 0;
  D.49909 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.49909;
  ins->prev = 0B;
  D.49910 = ins->prev;
  ins->next = D.49910;
  ins->opcode = 314;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.49911 = ins->sreg3;
  ins->sreg2 = D.49911;
  D.49912 = ins->sreg2;
  ins->sreg1 = D.49912;
  D.49913 = cfg->ip;
  ins->cil_code = D.49913;
  D.49914 = cfg->lmf_var;
  ins->data.op[0].p = D.49914;
  D.49914 = cfg->lmf_var;
  D.49914 = cfg->lmf_var;
  D.49915 = D.49914->flags;
  D.49916 = D.49915 | 16;
  D.49914->flags = D.49916;
  ins->type = 5;
  D.49914 = cfg->lmf_var;
  D.49917 = D.49914->klass;
  ins->klass = D.49917;
  D.49918 = alloc_dreg (cfg, 5);
  D.49919 = (int) D.49918;
  ins->dreg = D.49919;
  cfg->has_indirection = 1;
  D.49920 = cfg->gsharedvt;
  D.49921 = D.49920 != 0;
  D.49922 = (long int) D.49921;
  D.49923 = __builtin_expect (D.49922, 0);
  if (D.49923 != 0) goto <D.49924>; else goto <D.49925>;
  <D.49924>:
  D.49914 = cfg->lmf_var;
  D.49926 = D.49914->data.op[1].vtype;
  D.49927 = mini_is_gsharedvt_variable_type (cfg, D.49926);
  if (D.49927 != 0) goto <D.49928>; else goto <D.49929>;
  <D.49928>:
  handle_gsharedvt_ldaddr (cfg);
  <D.49929>:
  <D.49925>:
  if (0 != 0) goto <D.49930>; else goto <D.49931>;
  <D.49930>:
  {
    struct MonoInst * var1;
    struct MonoInst * var2;

    D.49914 = cfg->lmf_var;
    D.49933 = D.49914->dreg;
    D.49934 = D.49933 + 1;
    D.49935 = (unsigned int) D.49934;
    D.49936 = cfg->vreg_to_inst_len;
    if (D.49935 < D.49936) goto <D.49937>; else goto <D.49938>;
    <D.49937>:
    D.49939 = cfg->vreg_to_inst;
    D.49914 = cfg->lmf_var;
    D.49933 = D.49914->dreg;
    D.49940 = (sizetype) D.49933;
    D.49941 = D.49940 + 1;
    D.49942 = D.49941 * 8;
    D.49943 = D.49939 + D.49942;
    iftmp.439 = *D.49943;
    goto <D.49944>;
    <D.49938>:
    iftmp.439 = 0B;
    <D.49944>:
    var1 = iftmp.439;
    D.49914 = cfg->lmf_var;
    D.49933 = D.49914->dreg;
    D.49946 = D.49933 + 2;
    D.49947 = (unsigned int) D.49946;
    D.49936 = cfg->vreg_to_inst_len;
    if (D.49947 < D.49936) goto <D.49948>; else goto <D.49949>;
    <D.49948>:
    D.49939 = cfg->vreg_to_inst;
    D.49914 = cfg->lmf_var;
    D.49933 = D.49914->dreg;
    D.49940 = (sizetype) D.49933;
    D.49950 = D.49940 + 2;
    D.49951 = D.49950 * 8;
    D.49952 = D.49939 + D.49951;
    iftmp.440 = *D.49952;
    goto <D.49953>;
    <D.49949>:
    iftmp.440 = 0B;
    <D.49953>:
    var2 = iftmp.440;
    D.49954 = var1 == 0B;
    D.49955 = (long int) D.49954;
    D.49956 = __builtin_expect (D.49955, 0);
    if (D.49956 != 0) goto <D.49957>; else goto <D.49958>;
    <D.49957>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1924, "var1");
    <D.49958>:
    D.49959 = var2 == 0B;
    D.49960 = (long int) D.49959;
    D.49961 = __builtin_expect (D.49960, 0);
    if (D.49961 != 0) goto <D.49962>; else goto <D.49963>;
    <D.49962>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1924, "var2");
    <D.49963>:
    D.49964 = var1->flags;
    D.49965 = D.49964 | 16;
    var1->flags = D.49965;
    D.49966 = var2->flags;
    D.49967 = D.49966 | 16;
    var2->flags = D.49967;
  }
  <D.49931>:
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  if (D.49904 != 0B) goto <D.49968>; else goto <D.49969>;
  <D.49968>:
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  D.49904->next = ins;
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  ins->prev = D.49904;
  D.49903 = cfg->cbb;
  D.49903->last_ins = ins;
  goto <D.49970>;
  <D.49969>:
  D.49903 = cfg->cbb;
  D.49903 = cfg->cbb;
  D.49903->last_ins = ins;
  D.49904 = D.49903->last_ins;
  D.49903->code = D.49904;
  <D.49970>:
  lmf_reg = ins->dreg;
  D.49908 = cfg->mempool;
  ins = mono_mempool_alloc (D.49908, 80);
  ins->data.op[1].const_val = 0;
  D.49909 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.49909;
  ins->prev = 0B;
  D.49910 = ins->prev;
  ins->next = D.49910;
  ins->opcode = 374;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.49911 = ins->sreg3;
  ins->sreg2 = D.49911;
  D.49912 = ins->sreg2;
  ins->sreg1 = D.49912;
  D.49913 = cfg->ip;
  ins->cil_code = D.49913;
  D.49971 = lmf_ins->dreg;
  ins->sreg1 = D.49971;
  ins->dreg = lmf_reg;
  ins->data.op[0].const_val = 0;
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  if (D.49904 != 0B) goto <D.49972>; else goto <D.49973>;
  <D.49972>:
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  D.49904->next = ins;
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  ins->prev = D.49904;
  D.49903 = cfg->cbb;
  D.49903->last_ins = ins;
  goto <D.49974>;
  <D.49973>:
  D.49903 = cfg->cbb;
  D.49903 = cfg->cbb;
  D.49903->last_ins = ins;
  D.49904 = D.49903->last_ins;
  D.49903->code = D.49904;
  <D.49974>:
  emit_tls_set (cfg, lmf_reg, 3);
  goto <D.49893>;
  <D.49892>:
  D.49975 = cfg->lmf_addr_var;
  if (D.49975 == 0B) goto <D.49976>; else goto <D.49977>;
  <D.49976>:
  D.49978 = mono_defaults.int_class;
  D.49979 = &D.49978->byval_arg;
  D.49980 = mono_compile_create_var (cfg, D.49979, 329);
  cfg->lmf_addr_var = D.49980;
  <D.49977>:
  lmf_ins = mono_get_lmf_addr_intrinsic (cfg);
  if (lmf_ins != 0B) goto <D.49981>; else goto <D.49982>;
  <D.49981>:
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  if (D.49904 != 0B) goto <D.49983>; else goto <D.49984>;
  <D.49983>:
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  D.49904->next = lmf_ins;
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  lmf_ins->prev = D.49904;
  D.49903 = cfg->cbb;
  D.49903->last_ins = lmf_ins;
  goto <D.49985>;
  <D.49984>:
  D.49903 = cfg->cbb;
  D.49903 = cfg->cbb;
  D.49903->last_ins = lmf_ins;
  D.49904 = D.49903->last_ins;
  D.49903->code = D.49904;
  <D.49985>:
  goto <D.49986>;
  <D.49982>:
  lmf_ins = mono_emit_jit_icall (cfg, mono_get_lmf_addr, 0B);
  <D.49986>:
  D.49975 = cfg->lmf_addr_var;
  D.49987 = D.49975->dreg;
  lmf_ins->dreg = D.49987;
  D.49908 = cfg->mempool;
  ins = mono_mempool_alloc (D.49908, 80);
  ins->data.op[1].const_val = 0;
  D.49909 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.49909;
  ins->prev = 0B;
  D.49910 = ins->prev;
  ins->next = D.49910;
  ins->opcode = 314;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.49911 = ins->sreg3;
  ins->sreg2 = D.49911;
  D.49912 = ins->sreg2;
  ins->sreg1 = D.49912;
  D.49913 = cfg->ip;
  ins->cil_code = D.49913;
  D.49914 = cfg->lmf_var;
  ins->data.op[0].p = D.49914;
  D.49914 = cfg->lmf_var;
  D.49914 = cfg->lmf_var;
  D.49915 = D.49914->flags;
  D.49916 = D.49915 | 16;
  D.49914->flags = D.49916;
  ins->type = 5;
  D.49914 = cfg->lmf_var;
  D.49917 = D.49914->klass;
  ins->klass = D.49917;
  D.49988 = alloc_dreg (cfg, 5);
  D.49989 = (int) D.49988;
  ins->dreg = D.49989;
  cfg->has_indirection = 1;
  D.49920 = cfg->gsharedvt;
  D.49921 = D.49920 != 0;
  D.49922 = (long int) D.49921;
  D.49923 = __builtin_expect (D.49922, 0);
  if (D.49923 != 0) goto <D.49990>; else goto <D.49991>;
  <D.49990>:
  D.49914 = cfg->lmf_var;
  D.49926 = D.49914->data.op[1].vtype;
  D.49992 = mini_is_gsharedvt_variable_type (cfg, D.49926);
  if (D.49992 != 0) goto <D.49993>; else goto <D.49994>;
  <D.49993>:
  handle_gsharedvt_ldaddr (cfg);
  <D.49994>:
  <D.49991>:
  if (0 != 0) goto <D.49995>; else goto <D.49996>;
  <D.49995>:
  {
    struct MonoInst * var1;
    struct MonoInst * var2;

    D.49914 = cfg->lmf_var;
    D.49933 = D.49914->dreg;
    D.49934 = D.49933 + 1;
    D.49935 = (unsigned int) D.49934;
    D.49936 = cfg->vreg_to_inst_len;
    if (D.49935 < D.49936) goto <D.49998>; else goto <D.49999>;
    <D.49998>:
    D.49939 = cfg->vreg_to_inst;
    D.49914 = cfg->lmf_var;
    D.49933 = D.49914->dreg;
    D.49940 = (sizetype) D.49933;
    D.49941 = D.49940 + 1;
    D.49942 = D.49941 * 8;
    D.49943 = D.49939 + D.49942;
    iftmp.441 = *D.49943;
    goto <D.50000>;
    <D.49999>:
    iftmp.441 = 0B;
    <D.50000>:
    var1 = iftmp.441;
    D.49914 = cfg->lmf_var;
    D.49933 = D.49914->dreg;
    D.49946 = D.49933 + 2;
    D.49947 = (unsigned int) D.49946;
    D.49936 = cfg->vreg_to_inst_len;
    if (D.49947 < D.49936) goto <D.50002>; else goto <D.50003>;
    <D.50002>:
    D.49939 = cfg->vreg_to_inst;
    D.49914 = cfg->lmf_var;
    D.49933 = D.49914->dreg;
    D.49940 = (sizetype) D.49933;
    D.49950 = D.49940 + 2;
    D.49951 = D.49950 * 8;
    D.49952 = D.49939 + D.49951;
    iftmp.442 = *D.49952;
    goto <D.50004>;
    <D.50003>:
    iftmp.442 = 0B;
    <D.50004>:
    var2 = iftmp.442;
    D.50005 = var1 == 0B;
    D.50006 = (long int) D.50005;
    D.50007 = __builtin_expect (D.50006, 0);
    if (D.50007 != 0) goto <D.50008>; else goto <D.50009>;
    <D.50008>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1944, "var1");
    <D.50009>:
    D.50010 = var2 == 0B;
    D.50011 = (long int) D.50010;
    D.50012 = __builtin_expect (D.50011, 0);
    if (D.50012 != 0) goto <D.50013>; else goto <D.50014>;
    <D.50013>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 1944, "var2");
    <D.50014>:
    D.50015 = var1->flags;
    D.50016 = D.50015 | 16;
    var1->flags = D.50016;
    D.50017 = var2->flags;
    D.50018 = D.50017 | 16;
    var2->flags = D.50018;
  }
  <D.49996>:
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  if (D.49904 != 0B) goto <D.50019>; else goto <D.50020>;
  <D.50019>:
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  D.49904->next = ins;
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  ins->prev = D.49904;
  D.49903 = cfg->cbb;
  D.49903->last_ins = ins;
  goto <D.50021>;
  <D.50020>:
  D.49903 = cfg->cbb;
  D.49903 = cfg->cbb;
  D.49903->last_ins = ins;
  D.49904 = D.49903->last_ins;
  D.49903->code = D.49904;
  <D.50021>:
  lmf_reg = ins->dreg;
  D.50022 = alloc_preg (cfg);
  prev_lmf_reg = (int) D.50022;
  D.49908 = cfg->mempool;
  ins = mono_mempool_alloc (D.49908, 80);
  ins->data.op[1].const_val = 0;
  D.49909 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.49909;
  ins->prev = 0B;
  D.49910 = ins->prev;
  ins->next = D.49910;
  ins->opcode = 388;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.49911 = ins->sreg3;
  ins->sreg2 = D.49911;
  D.49912 = ins->sreg2;
  ins->sreg1 = D.49912;
  D.49913 = cfg->ip;
  ins->cil_code = D.49913;
  ins->dreg = prev_lmf_reg;
  D.49975 = cfg->lmf_addr_var;
  D.49987 = D.49975->dreg;
  ins->sreg1 = D.49987;
  ins->data.op[0].const_val = 0;
  ins->type = 1;
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  if (D.49904 != 0B) goto <D.50023>; else goto <D.50024>;
  <D.50023>:
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  D.49904->next = ins;
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  ins->prev = D.49904;
  D.49903 = cfg->cbb;
  D.49903->last_ins = ins;
  goto <D.50025>;
  <D.50024>:
  D.49903 = cfg->cbb;
  D.49903 = cfg->cbb;
  D.49903->last_ins = ins;
  D.49904 = D.49903->last_ins;
  D.49903->code = D.49904;
  <D.50025>:
  D.49908 = cfg->mempool;
  ins = mono_mempool_alloc (D.49908, 80);
  ins->data.op[1].const_val = 0;
  D.49909 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.49909;
  ins->prev = 0B;
  D.49910 = ins->prev;
  ins->next = D.49910;
  ins->opcode = 374;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.49911 = ins->sreg3;
  ins->sreg2 = D.49911;
  D.49912 = ins->sreg2;
  ins->sreg1 = D.49912;
  D.49913 = cfg->ip;
  ins->cil_code = D.49913;
  ins->sreg1 = prev_lmf_reg;
  ins->dreg = lmf_reg;
  ins->data.op[0].const_val = 0;
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  if (D.49904 != 0B) goto <D.50026>; else goto <D.50027>;
  <D.50026>:
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  D.49904->next = ins;
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  ins->prev = D.49904;
  D.49903 = cfg->cbb;
  D.49903->last_ins = ins;
  goto <D.50028>;
  <D.50027>:
  D.49903 = cfg->cbb;
  D.49903 = cfg->cbb;
  D.49903->last_ins = ins;
  D.49904 = D.49903->last_ins;
  D.49903->code = D.49904;
  <D.50028>:
  D.49908 = cfg->mempool;
  ins = mono_mempool_alloc (D.49908, 80);
  ins->data.op[1].const_val = 0;
  D.49909 = ins->data.op[1].const_val;
  ins->data.op[0].const_val = D.49909;
  ins->prev = 0B;
  D.49910 = ins->prev;
  ins->next = D.49910;
  ins->opcode = 374;
  ins->flags = 0;
  ins->type = 0;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.49911 = ins->sreg3;
  ins->sreg2 = D.49911;
  D.49912 = ins->sreg2;
  ins->sreg1 = D.49912;
  D.49913 = cfg->ip;
  ins->cil_code = D.49913;
  ins->sreg1 = lmf_reg;
  D.49975 = cfg->lmf_addr_var;
  D.49987 = D.49975->dreg;
  ins->dreg = D.49987;
  ins->data.op[0].const_val = 0;
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  if (D.49904 != 0B) goto <D.50029>; else goto <D.50030>;
  <D.50029>:
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  D.49904->next = ins;
  D.49903 = cfg->cbb;
  D.49904 = D.49903->last_ins;
  ins->prev = D.49904;
  D.49903 = cfg->cbb;
  D.49903->last_ins = ins;
  goto <D.50031>;
  <D.50030>:
  D.49903 = cfg->cbb;
  D.49903 = cfg->cbb;
  D.49903->last_ins = ins;
  D.49904 = D.49903->last_ins;
  D.49903->code = D.49904;
  <D.50031>:
  <D.49893>:
}


mono_find_block_region (struct MonoCompile * cfg, int offset)
{
  struct MonoExceptionClause * D.50033;
  long unsigned int D.50034;
  long unsigned int D.50035;
  unsigned int D.50036;
  unsigned int D.50039;
  unsigned int offset.443;
  unsigned int D.50043;
  int D.50046;
  int D.50047;
  int D.50048;
  unsigned int D.50049;
  unsigned int D.50050;
  unsigned int D.50051;
  unsigned int D.50054;
  unsigned int D.50055;
  unsigned int D.50060;
  unsigned int D.50063;
  unsigned int D.50064;
  unsigned int D.50065;
  unsigned int D.50068;
  unsigned int D.50069;
  <unnamed-unsigned:15> D.50072;
  int D.50073;
  struct MonoMethodHeader * header;
  struct MonoExceptionClause * clause;
  int i;

  header = cfg->header;
  i = 0;
  goto <D.25087>;
  <D.25086>:
  D.50033 = header->clauses;
  D.50034 = (long unsigned int) i;
  D.50035 = D.50034 * 32;
  clause = D.50033 + D.50035;
  D.50036 = clause->flags;
  if (D.50036 == 1) goto <D.50037>; else goto <D.50038>;
  <D.50037>:
  D.50039 = clause->data.filter_offset;
  offset.443 = (unsigned int) offset;
  if (D.50039 <= offset.443) goto <D.50041>; else goto <D.50042>;
  <D.50041>:
  D.50043 = clause->handler_offset;
  offset.443 = (unsigned int) offset;
  if (D.50043 > offset.443) goto <D.50044>; else goto <D.50045>;
  <D.50044>:
  D.50047 = i + 1;
  D.50048 = D.50047 << 8;
  D.50049 = (unsigned int) D.50048;
  D.50036 = clause->flags;
  D.50050 = D.50049 | D.50036;
  D.50051 = D.50050 | 128;
  D.50046 = (int) D.50051;
  return D.50046;
  <D.50045>:
  <D.50042>:
  <D.50038>:
  D.50043 = clause->handler_offset;
  offset.443 = (unsigned int) offset;
  if (D.50043 <= offset.443) goto <D.50052>; else goto <D.50053>;
  <D.50052>:
  D.50043 = clause->handler_offset;
  D.50054 = clause->handler_len;
  D.50055 = D.50043 + D.50054;
  offset.443 = (unsigned int) offset;
  if (D.50055 > offset.443) goto <D.50056>; else goto <D.50057>;
  <D.50056>:
  D.50036 = clause->flags;
  if (D.50036 == 2) goto <D.50058>; else goto <D.50059>;
  <D.50058>:
  D.50047 = i + 1;
  D.50048 = D.50047 << 8;
  D.50049 = (unsigned int) D.50048;
  D.50036 = clause->flags;
  D.50050 = D.50049 | D.50036;
  D.50060 = D.50050 | 16;
  D.50046 = (int) D.50060;
  return D.50046;
  <D.50059>:
  D.50036 = clause->flags;
  if (D.50036 == 4) goto <D.50061>; else goto <D.50062>;
  <D.50061>:
  D.50047 = i + 1;
  D.50048 = D.50047 << 8;
  D.50049 = (unsigned int) D.50048;
  D.50036 = clause->flags;
  D.50050 = D.50049 | D.50036;
  D.50063 = D.50050 | 64;
  D.50046 = (int) D.50063;
  return D.50046;
  <D.50062>:
  D.50047 = i + 1;
  D.50048 = D.50047 << 8;
  D.50049 = (unsigned int) D.50048;
  D.50036 = clause->flags;
  D.50050 = D.50049 | D.50036;
  D.50064 = D.50050 | 32;
  D.50046 = (int) D.50064;
  return D.50046;
  <D.50057>:
  <D.50053>:
  D.50065 = clause->try_offset;
  offset.443 = (unsigned int) offset;
  if (D.50065 <= offset.443) goto <D.50066>; else goto <D.50067>;
  <D.50066>:
  D.50065 = clause->try_offset;
  D.50068 = clause->try_len;
  D.50069 = D.50065 + D.50068;
  offset.443 = (unsigned int) offset;
  if (D.50069 > offset.443) goto <D.50070>; else goto <D.50071>;
  <D.50070>:
  D.50047 = i + 1;
  D.50048 = D.50047 << 8;
  D.50049 = (unsigned int) D.50048;
  D.50036 = clause->flags;
  D.50050 = D.50049 | D.50036;
  D.50046 = (int) D.50050;
  return D.50046;
  <D.50071>:
  <D.50067>:
  i = i + 1;
  <D.25087>:
  D.50072 = header->num_clauses;
  D.50073 = (int) D.50072;
  if (D.50073 > i) goto <D.25086>; else goto <D.25088>;
  <D.25088>:
  D.50046 = -1;
  return D.50046;
}


mono_create_spvar_for_region (struct MonoCompile * cfg, int region)
{
  struct GHashTable * D.50075;
  long int D.50076;
  const void * D.50077;
  struct MonoClass * D.50080;
  struct MonoType * D.50081;
  unsigned char D.50082;
  unsigned char D.50083;
  void * D.50084;
  struct MonoInst * var;

  D.50075 = cfg->spvars;
  D.50076 = (long int) region;
  D.50077 = (const void *) D.50076;
  var = monoeg_g_hash_table_lookup (D.50075, D.50077);
  if (var != 0B) goto <D.50078>; else goto <D.50079>;
  <D.50078>:
  return;
  <D.50079>:
  D.50080 = mono_defaults.int_class;
  D.50081 = &D.50080->byval_arg;
  var = mono_compile_create_var (cfg, D.50081, 329);
  D.50082 = var->flags;
  D.50083 = D.50082 | 4;
  var->flags = D.50083;
  D.50075 = cfg->spvars;
  D.50076 = (long int) region;
  D.50084 = (void *) D.50076;
  monoeg_g_hash_table_insert_replace (D.50075, D.50084, var, 0);
}


set_exception_type_from_invalid_il (struct MonoCompile * cfg, struct MonoMethod * method, unsigned char * ip)
{
  unsigned int D.50086;
  gchar * D.50090;
  struct MonoMemPool * D.50091;
  struct GSList * D.50092;
  struct GSList * D.50093;
  char * method_fname;
  char * method_code;
  struct MonoMethodHeader * header;

  method_fname = mono_method_full_name (method, 1);
  header = mono_method_get_header (method);
  D.50086 = header->code_size;
  if (D.50086 == 0) goto <D.50087>; else goto <D.50088>;
  <D.50087>:
  method_code = monoeg_strdup ("method body is empty.");
  goto <D.50089>;
  <D.50088>:
  method_code = mono_disasm_code_one (0B, method, ip, 0B);
  <D.50089>:
  mono_cfg_set_exception (cfg, 3);
  D.50090 = monoeg_g_strdup_printf ("Invalid IL code in %s: %s\n", method_fname, method_code);
  cfg->exception_message = D.50090;
  monoeg_g_free (method_fname);
  monoeg_g_free (method_code);
  D.50091 = cfg->mempool;
  D.50092 = cfg->headers_to_free;
  D.50093 = g_slist_prepend_mempool (D.50091, D.50092, header);
  cfg->headers_to_free = D.50093;
}


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

  if (str != 0B) goto <D.50094>; else goto <D.50095>;
  <D.50094>:
  D.50096 = __strdup (str);
  return D.50096;
  <D.50095>:
  D.50096 = 0B;
  return D.50096;
}


g_slist_prepend_mempool (struct MonoMemPool * mp, struct GSList * list, void * data)
{
  struct GSList * D.50098;
  struct GSList * new_list;

  new_list = mono_mempool_alloc (mp, 16);
  new_list->data = data;
  new_list->next = list;
  D.50098 = new_list;
  return D.50098;
}


__attribute__((visibility ("hidden")))
mono_op_to_op_imm (int opcode)
{
  int D.50100;

  switch (opcode) <default: <D.50101>, case 322: <D.28230>, case 325: <D.28232>, case 326: <D.28231>, case 338: <D.28241>, case 344: <D.28237>, case 347: <D.28238>, case 350: <D.28240>, case 353: <D.28239>, case 374: <D.28233>, case 375: <D.28234>, case 376: <D.28235>, case 377: <D.28236>, case 479: <D.28222>, case 480: <D.28223>, case 486: <D.28224>, case 487: <D.28225>, case 488: <D.28226>, case 489: <D.28227>, case 490: <D.28228>, case 491: <D.28229>, case 565: <D.28209>, case 566: <D.28210>, case 567: <D.28215>, case 568: <D.28211>, case 569: <D.28212>, case 570: <D.28213>, case 571: <D.28214>, case 572: <D.28216>, case 573: <D.28217>, case 574: <D.28218>, case 575: <D.28219>, case 576: <D.28220>, case 577: <D.28221>>
  <D.28209>:
  D.50100 = 625;
  return D.50100;
  <D.28210>:
  D.50100 = 626;
  return D.50100;
  <D.28211>:
  D.50100 = 628;
  return D.50100;
  <D.28212>:
  D.50100 = 629;
  return D.50100;
  <D.28213>:
  D.50100 = 630;
  return D.50100;
  <D.28214>:
  D.50100 = 631;
  return D.50100;
  <D.28215>:
  D.50100 = 627;
  return D.50100;
  <D.28216>:
  D.50100 = 632;
  return D.50100;
  <D.28217>:
  D.50100 = 633;
  return D.50100;
  <D.28218>:
  D.50100 = 634;
  return D.50100;
  <D.28219>:
  D.50100 = 635;
  return D.50100;
  <D.28220>:
  D.50100 = 636;
  return D.50100;
  <D.28221>:
  D.50100 = 637;
  return D.50100;
  <D.28222>:
  D.50100 = 538;
  return D.50100;
  <D.28223>:
  D.50100 = 539;
  return D.50100;
  <D.28224>:
  D.50100 = 541;
  return D.50100;
  <D.28225>:
  D.50100 = 542;
  return D.50100;
  <D.28226>:
  D.50100 = 543;
  return D.50100;
  <D.28227>:
  D.50100 = 544;
  return D.50100;
  <D.28228>:
  D.50100 = 545;
  return D.50100;
  <D.28229>:
  D.50100 = 546;
  return D.50100;
  <D.28230>:
  D.50100 = 323;
  return D.50100;
  <D.28231>:
  D.50100 = 327;
  return D.50100;
  <D.28232>:
  D.50100 = 328;
  return D.50100;
  <D.28233>:
  D.50100 = 381;
  return D.50100;
  <D.28234>:
  D.50100 = 382;
  return D.50100;
  <D.28235>:
  D.50100 = 383;
  return D.50100;
  <D.28236>:
  D.50100 = 384;
  return D.50100;
  <D.28237>:
  D.50100 = 343;
  return D.50100;
  <D.28238>:
  D.50100 = 346;
  return D.50100;
  <D.28239>:
  D.50100 = 352;
  return D.50100;
  <D.28240>:
  D.50100 = 349;
  return D.50100;
  <D.28241>:
  D.50100 = 339;
  return D.50100;
  <D.50101>:
  D.50100 = -1;
  return D.50100;
}


__attribute__((visibility ("hidden")))
mono_load_membase_to_load_mem (int opcode)
{
  int D.50103;

  D.50103 = -1;
  return D.50103;
}


mono_op_to_op_imm_noemul (int opcode)
{
  int D.50105;

  switch (opcode) <default: <D.28291>>
  <D.28291>:
  D.50105 = mono_op_to_op_imm (opcode);
  return D.50105;
}


__attribute__((visibility ("hidden")))
mono_handle_global_vregs (struct MonoCompile * cfg)
{
  struct MonoMemPool * D.50107;
  unsigned int D.50108;
  unsigned int D.50109;
  unsigned int D.50110;
  unsigned int D.50111;
  int D.50114;
  short unsigned int D.50115;
  int D.50116;
  int D.50117;
  int D.50118;
  _Bool D.50119;
  long int D.50120;
  long int D.50121;
  _Bool D.50124;
  long int D.50125;
  long int D.50126;
  char D.50131;
  const char * D.50137;
  char D.50138;
  const char * D.50144;
  char D.50145;
  const char * D.50151;
  char D.50152;
  _Bool D.50155;
  long int D.50156;
  long int D.50157;
  long unsigned int D.50160;
  long unsigned int D.50161;
  gint32 * D.50162;
  int D.50165;
  unsigned int D.50177;
  unsigned int vreg.444;
  struct MonoInst * * D.50180;
  long unsigned int D.50181;
  struct MonoInst * * D.50182;
  struct MonoInst * D.50183;
  int D.50186;
  unsigned int D.50189;
  gboolean * D.50191;
  gboolean * D.50192;
  int D.50193;
  struct MonoClass * D.50195;
  struct MonoType * D.50196;
  struct MonoClass * D.50197;
  struct MonoType * D.50198;
  struct MonoClass * D.50199;
  struct MonoType * D.50200;
  struct MonoClass * D.50201;
  struct MonoType * D.50202;
  struct MonoClass * D.50203;
  struct MonoType * D.50204;
  struct MonoInst * * D.50205;
  long unsigned int D.50206;
  long unsigned int D.50207;
  struct MonoInst * * D.50208;
  struct MonoMethodVar * D.50209;
  long unsigned int D.50210;
  unsigned char D.50211;
  int D.50212;
  int D.50213;
  short unsigned int D.50215;
  struct MonoInst * D.50218;
  unsigned char D.50221;
  int D.50222;
  int D.50223;
  int D.50226;
  long unsigned int D.50227;
  long unsigned int D.50228;
  gint32 * D.50229;
  int D.50230;
  struct MonoClass * D.50233;
  unsigned char D.50234;
  long unsigned int D.50237;
  long unsigned int D.50238;
  struct MonoInst * D.50241;
  struct MonoInst * D.50244;
  struct MonoInst * D.50247;
  unsigned int D.50252;
  unsigned char D.50253;
  long unsigned int D.50254;
  struct MonoInst * * D.50255;
  unsigned int D.50257;
  unsigned int i.445;
  unsigned int D.50261;
  unsigned int pos.446;
  unsigned char D.50265;
  int D.50266;
  int D.50267;
  long unsigned int D.50272;
  long unsigned int D.50273;
  struct MonoInst * * D.50274;
  struct MonoInst * D.50275;
  struct MonoInst * D.50276;
  long int D.50277;
  long unsigned int D.50278;
  struct MonoMethodVar * D.50279;
  struct MonoMethodVar * D.50280;
  gint32 * vreg_to_bb;
  struct MonoBasicBlock * bb;
  int i;
  int pos;

  D.50107 = cfg->mempool;
  D.50108 = cfg->next_vreg;
  D.50109 = D.50108 * 8;
  D.50110 = D.50109 + 1;
  vreg_to_bb = mono_mempool_alloc0 (D.50107, D.50110);
  bb = cfg->bb_entry;
  goto <D.28320>;
  <D.28319>:
  {
    struct MonoInst * ins;
    int block_num;

    ins = bb->code;
    block_num = bb->block_num;
    D.50111 = cfg->verbose_level;
    if (D.50111 > 2) goto <D.50112>; else goto <D.50113>;
    <D.50112>:
    D.50114 = bb->block_num;
    printf ("\nHANDLE-GLOBAL-VREGS BLOCK %d:\n", D.50114);
    <D.50113>:
    cfg->cbb = bb;
    goto <D.28317>;
    <D.28316>:
    {
      const char * spec;
      int regtype;
      int regindex;
      gint32 prev_bb;

      D.50115 = ins->opcode;
      D.50116 = (int) D.50115;
      D.50117 = D.50116 + -313;
      D.50118 = D.50117 * 4;
      spec = &ins_info[D.50118];
      regtype = 0;
      D.50111 = cfg->verbose_level;
      D.50119 = D.50111 > 2;
      D.50120 = (long int) D.50119;
      D.50121 = __builtin_expect (D.50120, 0);
      if (D.50121 != 0) goto <D.50122>; else goto <D.50123>;
      <D.50122>:
      mono_print_ins (ins);
      <D.50123>:
      D.50115 = ins->opcode;
      D.50124 = D.50115 <= 312;
      D.50125 = (long int) D.50124;
      D.50126 = __builtin_expect (D.50125, 0);
      if (D.50126 != 0) goto <D.50127>; else goto <D.50128>;
      <D.50127>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 12539, "ins->opcode >= MONO_CEE_LAST");
      <D.50128>:
      regindex = 0;
      goto <D.28314>;
      <D.28313>:
      {
        int vreg;

        vreg = 0;
        if (regindex == 0) goto <D.50129>; else goto <D.50130>;
        <D.50129>:
        D.50131 = *spec;
        regtype = (int) D.50131;
        if (regtype == 32) goto <D.50132>; else goto <D.50133>;
        <D.50132>:
        // predicted unlikely by continue predictor.
        goto <D.28306>;
        <D.50133>:
        vreg = ins->dreg;
        goto <D.50134>;
        <D.50130>:
        if (regindex == 1) goto <D.50135>; else goto <D.50136>;
        <D.50135>:
        D.50137 = spec + 1;
        D.50138 = *D.50137;
        regtype = (int) D.50138;
        if (regtype == 32) goto <D.50139>; else goto <D.50140>;
        <D.50139>:
        // predicted unlikely by continue predictor.
        goto <D.28306>;
        <D.50140>:
        vreg = ins->sreg1;
        goto <D.50141>;
        <D.50136>:
        if (regindex == 2) goto <D.50142>; else goto <D.50143>;
        <D.50142>:
        D.50144 = spec + 2;
        D.50145 = *D.50144;
        regtype = (int) D.50145;
        if (regtype == 32) goto <D.50146>; else goto <D.50147>;
        <D.50146>:
        // predicted unlikely by continue predictor.
        goto <D.28306>;
        <D.50147>:
        vreg = ins->sreg2;
        goto <D.50148>;
        <D.50143>:
        if (regindex == 3) goto <D.50149>; else goto <D.50150>;
        <D.50149>:
        D.50151 = spec + 3;
        D.50152 = *D.50151;
        regtype = (int) D.50152;
        if (regtype == 32) goto <D.50153>; else goto <D.50154>;
        <D.50153>:
        // predicted unlikely by continue predictor.
        goto <D.28306>;
        <D.50154>:
        vreg = ins->sreg3;
        <D.50150>:
        <D.50148>:
        <D.50141>:
        <D.50134>:
        D.50155 = vreg == -1;
        D.50156 = (long int) D.50155;
        D.50157 = __builtin_expect (D.50156, 0);
        if (D.50157 != 0) goto <D.50158>; else goto <D.50159>;
        <D.50158>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 12590, "vreg != -1");
        <D.50159>:
        D.50160 = (long unsigned int) vreg;
        D.50161 = D.50160 * 4;
        D.50162 = vreg_to_bb + D.50161;
        prev_bb = *D.50162;
        if (prev_bb == 0) goto <D.50163>; else goto <D.50164>;
        <D.50163>:
        D.50160 = (long unsigned int) vreg;
        D.50161 = D.50160 * 4;
        D.50162 = vreg_to_bb + D.50161;
        D.50165 = block_num + 1;
        *D.50162 = D.50165;
        goto <D.50166>;
        <D.50164>:
        D.50165 = block_num + 1;
        if (D.50165 != prev_bb) goto <D.50167>; else goto <D.50168>;
        <D.50167>:
        if (prev_bb != -1) goto <D.50169>; else goto <D.50170>;
        <D.50169>:
        if (regtype == 105) goto <D.50171>; else goto <D.50173>;
        <D.50173>:
        if (regtype == 102) goto <D.50171>; else goto <D.50172>;
        <D.50171>:
        if (vreg <= 15) goto <D.50174>; else goto <D.50175>;
        <D.50174>:
        // predicted unlikely by continue predictor.
        goto <D.28306>;
        <D.50175>:
        <D.50172>:
        D.50177 = cfg->vreg_to_inst_len;
        vreg.444 = (unsigned int) vreg;
        if (D.50177 <= vreg.444) goto <D.50176>; else goto <D.50179>;
        <D.50179>:
        D.50180 = cfg->vreg_to_inst;
        D.50160 = (long unsigned int) vreg;
        D.50181 = D.50160 * 8;
        D.50182 = D.50180 + D.50181;
        D.50183 = *D.50182;
        if (D.50183 == 0B) goto <D.50176>; else goto <D.28308>;
        <D.50176>:
        D.50111 = cfg->verbose_level;
        D.50119 = D.50111 > 2;
        D.50120 = (long int) D.50119;
        D.50121 = __builtin_expect (D.50120, 0);
        if (D.50121 != 0) goto <D.50184>; else goto <D.50185>;
        <D.50184>:
        D.50160 = (long unsigned int) vreg;
        D.50161 = D.50160 * 4;
        D.50162 = vreg_to_bb + D.50161;
        D.50186 = *D.50162;
        printf ("VREG R%d used in BB%d and BB%d made global.\n", vreg, D.50186, block_num);
        <D.50185>:
        switch (regtype) <default: <D.28312>, case 102: <D.28310>, case 105: <D.28307>, case 108: <D.28309>, case 118: <D.28311>>
        <D.28307>:
        D.50189 = cfg->vreg_is_ref_len;
        vreg.444 = (unsigned int) vreg;
        if (D.50189 > vreg.444) goto <D.50190>; else goto <D.50187>;
        <D.50190>:
        D.50191 = cfg->vreg_is_ref;
        D.50160 = (long unsigned int) vreg;
        D.50161 = D.50160 * 4;
        D.50192 = D.50191 + D.50161;
        D.50193 = *D.50192;
        if (D.50193 != 0) goto <D.50194>; else goto <D.50187>;
        <D.50194>:
        D.50195 = mono_defaults.object_class;
        D.50196 = &D.50195->byval_arg;
        mono_compile_create_var_for_vreg (cfg, D.50196, 329, vreg);
        goto <D.50188>;
        <D.50187>:
        D.50197 = mono_defaults.int_class;
        D.50198 = &D.50197->byval_arg;
        mono_compile_create_var_for_vreg (cfg, D.50198, 329, vreg);
        <D.50188>:
        goto <D.28308>;
        <D.28309>:
        D.50199 = mono_defaults.int64_class;
        D.50200 = &D.50199->byval_arg;
        mono_compile_create_var_for_vreg (cfg, D.50200, 329, vreg);
        goto <D.28308>;
        <D.28310>:
        D.50201 = mono_defaults.double_class;
        D.50202 = &D.50201->byval_arg;
        mono_compile_create_var_for_vreg (cfg, D.50202, 329, vreg);
        goto <D.28308>;
        <D.28311>:
        D.50203 = ins->klass;
        D.50204 = &D.50203->byval_arg;
        mono_compile_create_var_for_vreg (cfg, D.50204, 329, vreg);
        goto <D.28308>;
        <D.28312>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 12621);
        <D.28308>:
        D.50160 = (long unsigned int) vreg;
        D.50161 = D.50160 * 4;
        D.50162 = vreg_to_bb + D.50161;
        *D.50162 = -1;
        <D.50170>:
        <D.50168>:
        <D.50166>:
      }
      <D.28306>:
      regindex = regindex + 1;
      <D.28314>:
      if (regindex <= 3) goto <D.28313>; else goto <D.28315>;
      <D.28315>:
    }
    ins = ins->next;
    <D.28317>:
    if (ins != 0B) goto <D.28316>; else goto <D.28318>;
    <D.28318>:
  }
  bb = bb->next_bb;
  <D.28320>:
  if (bb != 0B) goto <D.28319>; else goto <D.28321>;
  <D.28321>:
  i = 0;
  goto <D.28333>;
  <D.28332>:
  {
    struct MonoInst * var;
    struct MonoMethodVar * vmv;

    D.50205 = cfg->varinfo;
    D.50206 = (long unsigned int) i;
    D.50207 = D.50206 * 8;
    D.50208 = D.50205 + D.50207;
    var = *D.50208;
    D.50209 = cfg->vars;
    D.50206 = (long unsigned int) i;
    D.50210 = D.50206 * 80;
    vmv = D.50209 + D.50210;
    D.50211 = var->type;
    D.50212 = (int) D.50211;
    switch (D.50212) <default: <D.50256>, case 1: <D.28324>, case 2: <D.28329>, case 3: <D.28326>, case 4: <D.28330>, case 5: <D.28327>, case 6: <D.28325>, case 7: <D.28328>>
    <D.28324>:
    <D.28325>:
    <D.28326>:
    <D.28327>:
    <D.28328>:
    <D.28329>:
    <D.28330>:
    D.50213 = mono_arch_is_soft_float ();
    if (D.50213 != 0) goto <D.28331>; else goto <D.50214>;
    <D.50214>:
    D.50215 = var->opcode;
    if (D.50215 != 330) goto <D.50216>; else goto <D.50217>;
    <D.50216>:
    D.50218 = cfg->ret;
    if (D.50218 != var) goto <D.50219>; else goto <D.50220>;
    <D.50219>:
    D.50221 = var->flags;
    D.50222 = (int) D.50221;
    D.50223 = D.50222 & 20;
    if (D.50223 == 0) goto <D.50224>; else goto <D.50225>;
    <D.50224>:
    D.50226 = var->dreg;
    D.50227 = (long unsigned int) D.50226;
    D.50228 = D.50227 * 4;
    D.50229 = vreg_to_bb + D.50228;
    D.50230 = *D.50229;
    if (D.50230 != -1) goto <D.50231>; else goto <D.50232>;
    <D.50231>:
    D.50233 = var->klass;
    D.50234 = D.50233->byval_arg.type;
    if (D.50234 != 12) goto <D.50235>; else goto <D.50236>;
    <D.50235>:
    D.50237 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.50238 = D.50237 & 512;
    if (D.50238 == 0) goto <D.50239>; else goto <D.50240>;
    <D.50239>:
    D.50241 = cfg->gsharedvt_info_var;
    if (D.50241 != var) goto <D.50242>; else goto <D.50243>;
    <D.50242>:
    D.50244 = cfg->gsharedvt_locals_var;
    if (D.50244 != var) goto <D.50245>; else goto <D.50246>;
    <D.50245>:
    D.50247 = cfg->lmf_addr_var;
    if (D.50247 != var) goto <D.50248>; else goto <D.50249>;
    <D.50248>:
    D.50111 = cfg->verbose_level;
    D.50119 = D.50111 > 2;
    D.50120 = (long int) D.50119;
    D.50121 = __builtin_expect (D.50120, 0);
    if (D.50121 != 0) goto <D.50250>; else goto <D.50251>;
    <D.50250>:
    D.50226 = var->dreg;
    D.50252 = vmv->idx;
    printf ("CONVERTED R%d(%d) TO VREG.\n", D.50226, D.50252);
    <D.50251>:
    D.50221 = var->flags;
    D.50253 = D.50221 | 2;
    var->flags = D.50253;
    D.50180 = cfg->vreg_to_inst;
    D.50226 = var->dreg;
    D.50227 = (long unsigned int) D.50226;
    D.50254 = D.50227 * 8;
    D.50255 = D.50180 + D.50254;
    *D.50255 = 0B;
    <D.50249>:
    <D.50246>:
    <D.50243>:
    <D.50240>:
    <D.50236>:
    <D.50232>:
    <D.50225>:
    <D.50220>:
    <D.50217>:
    goto <D.28331>;
    <D.50256>:
    <D.28331>:
  }
  i = i + 1;
  <D.28333>:
  D.50257 = cfg->num_varinfo;
  i.445 = (unsigned int) i;
  if (D.50257 > i.445) goto <D.28332>; else goto <D.28334>;
  <D.28334>:
  pos = 0;
  i = 0;
  goto <D.28337>;
  <D.28336>:
  {
    struct MonoInst * var;

    D.50205 = cfg->varinfo;
    D.50206 = (long unsigned int) i;
    D.50207 = D.50206 * 8;
    D.50208 = D.50205 + D.50207;
    var = *D.50208;
    if (pos < i) goto <D.50259>; else goto <D.50260>;
    <D.50259>:
    D.50261 = cfg->locals_start;
    i.445 = (unsigned int) i;
    if (D.50261 == i.445) goto <D.50262>; else goto <D.50263>;
    <D.50262>:
    pos.446 = (unsigned int) pos;
    cfg->locals_start = pos.446;
    <D.50263>:
    <D.50260>:
    D.50265 = var->flags;
    D.50266 = (int) D.50265;
    D.50267 = D.50266 & 2;
    if (D.50267 == 0) goto <D.50268>; else goto <D.50269>;
    <D.50268>:
    if (pos < i) goto <D.50270>; else goto <D.50271>;
    <D.50270>:
    D.50205 = cfg->varinfo;
    D.50272 = (long unsigned int) pos;
    D.50273 = D.50272 * 8;
    D.50274 = D.50205 + D.50273;
    D.50205 = cfg->varinfo;
    D.50206 = (long unsigned int) i;
    D.50207 = D.50206 * 8;
    D.50208 = D.50205 + D.50207;
    D.50275 = *D.50208;
    *D.50274 = D.50275;
    D.50205 = cfg->varinfo;
    D.50272 = (long unsigned int) pos;
    D.50273 = D.50272 * 8;
    D.50274 = D.50205 + D.50273;
    D.50276 = *D.50274;
    D.50277 = (long int) pos;
    D.50276->data.op[0].const_val = D.50277;
    D.50209 = cfg->vars;
    D.50272 = (long unsigned int) pos;
    D.50278 = D.50272 * 80;
    D.50279 = D.50209 + D.50278;
    D.50209 = cfg->vars;
    D.50206 = (long unsigned int) i;
    D.50210 = D.50206 * 80;
    D.50280 = D.50209 + D.50210;
    memcpy (D.50279, D.50280, 80);
    D.50209 = cfg->vars;
    D.50272 = (long unsigned int) pos;
    D.50278 = D.50272 * 80;
    D.50279 = D.50209 + D.50278;
    pos.446 = (unsigned int) pos;
    D.50279->idx = pos.446;
    <D.50271>:
    pos = pos + 1;
    <D.50269>:
  }
  i = i + 1;
  <D.28337>:
  D.50257 = cfg->num_varinfo;
  i.445 = (unsigned int) i;
  if (D.50257 > i.445) goto <D.28336>; else goto <D.28338>;
  <D.28338>:
  pos.446 = (unsigned int) pos;
  cfg->num_varinfo = pos.446;
  D.50261 = cfg->locals_start;
  D.50257 = cfg->num_varinfo;
  if (D.50261 > D.50257) goto <D.50281>; else goto <D.50282>;
  <D.50281>:
  D.50257 = cfg->num_varinfo;
  cfg->locals_start = D.50257;
  <D.50282>:
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.50283;
  long unsigned int D.50284;

  D.50284 = __builtin_object_size (__dest, 0);
  D.50283 = __builtin___memcpy_chk (__dest, __src, __len, D.50284);
  return D.50283;
}


__attribute__((visibility ("hidden")))
mono_spill_global_vars (struct MonoCompile * cfg, gboolean * need_local_opts)
{
  long unsigned int D.50286;
  long unsigned int D.50287;
  struct MonoInst * * D.50290;
  long unsigned int D.50291;
  long unsigned int D.50292;
  struct MonoInst * * D.50293;
  short unsigned int D.50294;
  unsigned char D.50297;
  unsigned char D.50298;
  unsigned int D.50299;
  int D.50300;
  unsigned int D.50303;
  long unsigned int D.50304;
  long unsigned int D.50305;
  struct MonoType * D.50306;
  int D.50307;
  unsigned int D.50310;
  int D.50313;
  long unsigned int D.50314;
  long unsigned int D.50315;
  int * D.50316;
  int D.50317;
  long int D.50318;
  struct MonoMemPool * D.50320;
  unsigned int D.50321;
  long unsigned int D.50322;
  unsigned int D.50323;
  int D.50326;
  long unsigned int D.50327;
  guint32 * D.50328;
  unsigned int D.50329;
  long unsigned int D.50330;
  long unsigned int D.50331;
  guint32 * D.50332;
  short unsigned int D.50333;
  int D.50334;
  int D.50335;
  int D.50336;
  _Bool D.50337;
  long int D.50338;
  long int D.50339;
  short unsigned int D.50346;
  short unsigned int D.50349;
  int D.50352;
  struct MonoInst * D.50354;
  short unsigned int D.50355;
  int D.50358;
  long int D.50359;
  int D.50365;
  long unsigned int D.50366;
  long unsigned int D.50367;
  int * D.50368;
  int D.50369;
  _Bool D.50371;
  long int D.50372;
  long int D.50373;
  int D.50376;
  long int D.50377;
  _Bool D.50382;
  long int D.50383;
  long int D.50384;
  _Bool D.50387;
  long int D.50388;
  long int D.50389;
  _Bool D.50392;
  long int D.50393;
  long int D.50394;
  short unsigned int D.50397;
  unsigned int D.50400;
  long int D.50401;
  struct MonoInst * D.50402;
  int D.50403;
  int D.50404;
  const unsigned char * D.50405;
  int D.50406;
  long int D.50407;
  unsigned int D.50412;
  long int D.50413;
  struct MonoInst * D.50414;
  int D.50415;
  int D.50416;
  long unsigned int D.50417;
  long unsigned int D.50418;
  long unsigned int D.50419;
  long int D.50420;
  unsigned int D.50421;
  short unsigned int D.50422;
  long int D.50425;
  struct MonoInst * D.50426;
  int D.50427;
  int D.50428;
  int D.50429;
  long int D.50430;
  int D.50434;
  _Bool D.50438;
  long int D.50439;
  long int D.50440;
  short unsigned int D.50445;
  int D.50448;
  char D.50449;
  char D.50450;
  short unsigned int D.50452;
  int D.50457;
  int D.50458;
  int D.50459;
  signed char D.50460;
  int D.50461;
  int iftmp.447;
  _Bool D.50469;
  long int D.50470;
  long int D.50471;
  unsigned int D.50476;
  unsigned int D.50477;
  struct MonoInst * * D.50480;
  long unsigned int D.50481;
  long unsigned int D.50482;
  struct MonoInst * * D.50483;
  struct MonoInst * D.50484;
  struct MonoInst * iftmp.448;
  struct MonoType * D.50491;
  unsigned int D.50492;
  short unsigned int D.50493;
  int D.50496;
  const char * D.50502;
  char D.50503;
  long unsigned int D.50505;
  guint32 * D.50506;
  unsigned int D.50507;
  int D.50509;
  _Bool D.50511;
  long int D.50512;
  long int D.50513;
  int D.50519;
  short unsigned int D.50520;
  int D.50521;
  long int D.50522;
  unsigned int D.50527;
  unsigned int D.50528;
  int D.50529;
  _Bool D.50530;
  long int D.50531;
  long int D.50532;
  long int D.50541;
  int D.50542;
  short unsigned int D.50543;
  short unsigned int D.50550;
  int D.50554;
  int D.50556;
  short unsigned int D.50557;
  long int D.50558;
  struct MonoInst * D.50559;
  int D.50560;
  int D.50561;
  unsigned char D.50562;
  int D.50563;
  int D.50564;
  long unsigned int D.50569;
  long unsigned int D.50570;
  struct MonoInst * * D.50571;
  struct MonoInst * D.50572;
  struct MonoBasicBlock * * D.50575;
  signed char D.50580;
  long int D.50583;
  struct MonoInst * D.50584;
  int D.50585;
  int D.50586;
  long int D.50587;
  int D.50588;
  sizetype D.50589;
  const char * D.50590;
  char D.50591;
  int iftmp.449;
  _Bool D.50599;
  long int D.50600;
  long int D.50601;
  unsigned int sreg.450;
  long unsigned int D.50609;
  long unsigned int D.50610;
  struct MonoInst * * D.50611;
  struct MonoInst * D.50612;
  struct MonoInst * iftmp.451;
  short unsigned int D.50619;
  int D.50622;
  struct MonoInst * * D.50623;
  struct MonoBasicBlock * * D.50624;
  unsigned char D.50629;
  signed char D.50630;
  long int D.50633;
  struct MonoInst * D.50634;
  int D.50635;
  int D.50636;
  long int D.50637;
  _Bool D.50638;
  long int D.50639;
  long int D.50640;
  struct MonoType * D.50643;
  _Bool D.50644;
  long int D.50645;
  long int D.50646;
  long unsigned int D.50649;
  guint32 * D.50650;
  unsigned int D.50651;
  _Bool D.50654;
  long int D.50655;
  long int D.50656;
  int D.50661;
  int load_opcode.452;
  int D.50666;
  int D.50668;
  short unsigned int D.50669;
  int D.50670;
  long int D.50671;
  int D.50675;
  int D.50677;
  short unsigned int D.50678;
  unsigned int D.50683;
  int D.50684;
  int D.50685;
  _Bool D.50692;
  long int D.50693;
  long int D.50694;
  long unsigned int D.50697;
  long unsigned int D.50698;
  guint32 * D.50699;
  _Bool D.50700;
  long int D.50701;
  long int D.50702;
  unsigned int lvregs_len.453;
  long unsigned int D.50706;
  long unsigned int D.50707;
  guint32 * D.50708;
  unsigned int D.50709;
  long int D.50710;
  struct MonoInst * D.50711;
  short unsigned int D.50712;
  int D.50713;
  int D.50714;
  long unsigned int D.50717;
  struct MonoInst * * D.50718;
  struct MonoBasicBlock * * D.50719;
  long int D.50726;
  struct MonoInst * D.50727;
  int D.50728;
  int D.50729;
  long int D.50730;
  _Bool D.50733;
  long int D.50734;
  long int D.50735;
  long unsigned int D.50738;
  long unsigned int D.50739;
  guint32 * D.50740;
  unsigned int lvregs_len.454;
  long unsigned int D.50744;
  long unsigned int D.50745;
  guint32 * D.50746;
  unsigned int prev_dreg.455;
  short unsigned int D.50753;
  short unsigned int D.50755;
  short unsigned int D.50757;
  short unsigned int D.50759;
  short unsigned int D.50761;
  short unsigned int D.50763;
  long unsigned int D.50769;
  long unsigned int D.50770;
  struct MonoBitSet * D.50773;
  struct MonoInst * D.50776;
  struct MonoMethodVar * D.50779;
  long unsigned int D.50780;
  int iftmp.456;
  int D.50784;
  unsigned int D.50785;
  long unsigned int D.50787;
  long unsigned int D.50788;
  struct MonoInst * * D.50789;
  struct MonoInst * D.50790;
  struct MonoInst * iftmp.457;
  unsigned char D.50796;
  int D.50797;
  int D.50798;
  _Bool D.50800;
  long int D.50801;
  long int D.50802;
  struct MonoBitSet * D.50805;
  unsigned int D.50806;
  long unsigned int D.50807;
  long unsigned int D.50808;
  unsigned int D.50809;
  long unsigned int D.50810;
  long unsigned int D.50811;
  struct MonoInst * * D.50814;
  struct MonoInst * D.50815;
  struct MonoBasicBlock * * D.50818;
  long unsigned int D.50819;
  long unsigned int D.50820;
  long unsigned int D.50821;
  struct MonoInst * * D.50824;
  struct MonoInst * D.50825;
  struct MonoBasicBlock * * D.50826;
  struct MonoInst * D.50827;
  struct MonoBasicBlock * bb;
  char spec2[16];
  int orig_next_vreg;
  guint32 * vreg_to_lvreg;
  guint32 * lvregs;
  guint32 i;
  guint32 lvregs_len;
  gboolean dest_has_lvreg;
  guint32 stacktypes[128];
  struct MonoInst * * live_range_start;
  struct MonoInst * * live_range_end;
  struct MonoBasicBlock * * live_range_start_bb;
  struct MonoBasicBlock * * live_range_end_bb;
  int * gsharedvt_vreg_to_idx;

  try
    {
      dest_has_lvreg = 0;
      gsharedvt_vreg_to_idx = 0B;
      *need_local_opts = 0;
      memset (&spec2, 0, 16);
      stacktypes[105] = 3;
      stacktypes[108] = 2;
      stacktypes[102] = 4;
      D.50286 = BIT_FIELD_REF <*cfg, 64, 5632>;
      D.50287 = D.50286 & 72057594037927936;
      if (D.50287 != 0) goto <D.50288>; else goto <D.50289>;
      <D.50288>:
      i = 0;
      goto <D.28359>;
      <D.28358>:
      {
        struct MonoInst * ins;

        D.50290 = cfg->varinfo;
        D.50291 = (long unsigned int) i;
        D.50292 = D.50291 * 8;
        D.50293 = D.50290 + D.50292;
        ins = *D.50293;
        D.50294 = ins->opcode;
        if (D.50294 == 366) goto <D.50295>; else goto <D.50296>;
        <D.50295>:
        D.50297 = ins->flags;
        D.50298 = D.50297 | 128;
        ins->flags = D.50298;
        <D.50296>:
      }
      i = i + 1;
      <D.28359>:
      D.50299 = cfg->num_varinfo;
      if (D.50299 > i) goto <D.28358>; else goto <D.28360>;
      <D.28360>:
      <D.50289>:
      D.50300 = cfg->gsharedvt;
      if (D.50300 != 0) goto <D.50301>; else goto <D.50302>;
      <D.50301>:
      D.50303 = cfg->next_vreg;
      D.50304 = (long unsigned int) D.50303;
      D.50305 = D.50304 * 4;
      gsharedvt_vreg_to_idx = monoeg_malloc0 (D.50305);
      i = 0;
      goto <D.28364>;
      <D.28363>:
      {
        struct MonoInst * ins;
        int idx;

        D.50290 = cfg->varinfo;
        D.50291 = (long unsigned int) i;
        D.50292 = D.50291 * 8;
        D.50293 = D.50290 + D.50292;
        ins = *D.50293;
        D.50306 = ins->data.op[1].vtype;
        D.50307 = mini_is_gsharedvt_variable_type (cfg, D.50306);
        if (D.50307 != 0) goto <D.50308>; else goto <D.50309>;
        <D.50308>:
        D.50310 = cfg->locals_start;
        if (D.50310 <= i) goto <D.50311>; else goto <D.50312>;
        <D.50311>:
        D.50306 = ins->data.op[1].vtype;
        idx = get_gsharedvt_info_slot (cfg, D.50306, 21);
        D.50313 = ins->dreg;
        D.50314 = (long unsigned int) D.50313;
        D.50315 = D.50314 * 4;
        D.50316 = gsharedvt_vreg_to_idx + D.50315;
        D.50317 = idx + 1;
        *D.50316 = D.50317;
        ins->opcode = 331;
        D.50318 = (long int) idx;
        ins->data.op[1].const_val = D.50318;
        goto <D.50319>;
        <D.50312>:
        D.50313 = ins->dreg;
        D.50314 = (long unsigned int) D.50313;
        D.50315 = D.50314 * 4;
        D.50316 = gsharedvt_vreg_to_idx + D.50315;
        *D.50316 = -1;
        ins->opcode = 332;
        <D.50319>:
        <D.50309>:
      }
      i = i + 1;
      <D.28364>:
      D.50299 = cfg->num_varinfo;
      if (D.50299 > i) goto <D.28363>; else goto <D.28365>;
      <D.28365>:
      <D.50302>:
      D.50303 = cfg->next_vreg;
      orig_next_vreg = (int) D.50303;
      D.50320 = cfg->mempool;
      D.50303 = cfg->next_vreg;
      D.50321 = D.50303 * 4;
      vreg_to_lvreg = mono_mempool_alloc0 (D.50320, D.50321);
      D.50320 = cfg->mempool;
      lvregs = mono_mempool_alloc (D.50320, 4096);
      lvregs_len = 0;
      D.50303 = cfg->next_vreg;
      D.50304 = (long unsigned int) D.50303;
      D.50322 = D.50304 * 8;
      live_range_start = monoeg_malloc0 (D.50322);
      D.50303 = cfg->next_vreg;
      D.50304 = (long unsigned int) D.50303;
      D.50322 = D.50304 * 8;
      live_range_end = monoeg_malloc0 (D.50322);
      D.50303 = cfg->next_vreg;
      D.50304 = (long unsigned int) D.50303;
      D.50322 = D.50304 * 8;
      live_range_start_bb = monoeg_malloc (D.50322);
      D.50303 = cfg->next_vreg;
      D.50304 = (long unsigned int) D.50303;
      D.50322 = D.50304 * 8;
      live_range_end_bb = monoeg_malloc (D.50322);
      bb = cfg->bb_entry;
      goto <D.28424>;
      <D.28423>:
      {
        struct MonoInst * ins;

        D.50323 = cfg->verbose_level;
        if (D.50323 > 2) goto <D.50324>; else goto <D.50325>;
        <D.50324>:
        D.50326 = bb->block_num;
        printf ("\nSPILL BLOCK %d:\n", D.50326);
        <D.50325>:
        i = 0;
        goto <D.28368>;
        <D.28367>:
        D.50291 = (long unsigned int) i;
        D.50327 = D.50291 * 4;
        D.50328 = lvregs + D.50327;
        D.50329 = *D.50328;
        D.50330 = (long unsigned int) D.50329;
        D.50331 = D.50330 * 4;
        D.50332 = vreg_to_lvreg + D.50331;
        *D.50332 = 0;
        i = i + 1;
        <D.28368>:
        if (i < lvregs_len) goto <D.28367>; else goto <D.28369>;
        <D.28369>:
        lvregs_len = 0;
        cfg->cbb = bb;
        ins = bb->code;
        goto <D.28416>;
        <D.28415>:
        {
          const char * spec;
          int regtype;
          int srcindex;
          int sreg;
          int tmp_reg;
          int prev_dreg;
          int num_sregs;
          gboolean store;
          gboolean no_lvreg;
          int sregs[3];

          try
            {
              D.50333 = ins->opcode;
              D.50334 = (int) D.50333;
              D.50335 = D.50334 + -313;
              D.50336 = D.50335 * 4;
              spec = &ins_info[D.50336];
              D.50323 = cfg->verbose_level;
              D.50337 = D.50323 > 2;
              D.50338 = (long int) D.50337;
              D.50339 = __builtin_expect (D.50338, 0);
              if (D.50339 != 0) goto <D.50340>; else goto <D.50341>;
              <D.50340>:
              mono_print_ins (ins);
              <D.50341>:
              D.50333 = ins->opcode;
              if (D.50333 == 316) goto <D.50342>; else goto <D.50343>;
              <D.50342>:
              // predicted unlikely by continue predictor.
              goto <D.28380>;
              <D.50343>:
              D.50333 = ins->opcode;
              if (D.50333 == 314) goto <D.50344>; else goto <D.50345>;
              <D.50344>:
              {
                struct MonoInst * var;

                var = ins->data.op[0].p;
                D.50346 = var->opcode;
                if (D.50346 == 368) goto <D.50347>; else goto <D.50348>;
                <D.50347>:
                {
                  struct MonoInst * vtaddr;

                  vtaddr = var->data.op[0].src;
                  D.50349 = vtaddr->opcode;
                  if (D.50349 == 366) goto <D.50350>; else goto <D.50351>;
                  <D.50350>:
                  ins->opcode = 424;
                  D.50352 = vtaddr->dreg;
                  ins->sreg1 = D.50352;
                  goto <D.50353>;
                  <D.50351>:
                  D.50354 = var->data.op[0].src;
                  D.50355 = D.50354->opcode;
                  if (D.50355 == 367) goto <D.50356>; else goto <D.50357>;
                  <D.50356>:
                  ins->opcode = 388;
                  D.50358 = vtaddr->sreg1;
                  ins->sreg1 = D.50358;
                  D.50359 = vtaddr->data.op[0].const_val;
                  ins->data.op[0].const_val = D.50359;
                  goto <D.50360>;
                  <D.50357>:
                  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 12918);
                  <D.50360>:
                  <D.50353>:
                }
                goto <D.50361>;
                <D.50348>:
                D.50300 = cfg->gsharedvt;
                if (D.50300 != 0) goto <D.50364>; else goto <D.50362>;
                <D.50364>:
                D.50365 = var->dreg;
                D.50366 = (long unsigned int) D.50365;
                D.50367 = D.50366 * 4;
                D.50368 = gsharedvt_vreg_to_idx + D.50367;
                D.50369 = *D.50368;
                if (D.50369 < 0) goto <D.50370>; else goto <D.50362>;
                <D.50370>:
                D.50346 = var->opcode;
                D.50371 = D.50346 != 332;
                D.50372 = (long int) D.50371;
                D.50373 = __builtin_expect (D.50372, 0);
                if (D.50373 != 0) goto <D.50374>; else goto <D.50375>;
                <D.50374>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 12921, "var->opcode == OP_GSHAREDVT_ARG_REGOFFSET");
                <D.50375>:
                ins->opcode = 388;
                D.50376 = var->sreg1;
                ins->sreg1 = D.50376;
                D.50377 = var->data.op[0].const_val;
                ins->data.op[0].const_val = D.50377;
                goto <D.50363>;
                <D.50362>:
                D.50300 = cfg->gsharedvt;
                if (D.50300 != 0) goto <D.50380>; else goto <D.50378>;
                <D.50380>:
                D.50365 = var->dreg;
                D.50366 = (long unsigned int) D.50365;
                D.50367 = D.50366 * 4;
                D.50368 = gsharedvt_vreg_to_idx + D.50367;
                D.50369 = *D.50368;
                if (D.50369 != 0) goto <D.50381>; else goto <D.50378>;
                <D.50381>:
                {
                  struct MonoInst * load;
                  struct MonoInst * load2;
                  struct MonoInst * load3;
                  int idx;
                  int reg1;
                  int reg2;
                  int reg3;
                  struct MonoInst * info_var;
                  struct MonoInst * locals_var;

                  D.50365 = var->dreg;
                  D.50366 = (long unsigned int) D.50365;
                  D.50367 = D.50366 * 4;
                  D.50368 = gsharedvt_vreg_to_idx + D.50367;
                  D.50369 = *D.50368;
                  idx = D.50369 + -1;
                  info_var = cfg->gsharedvt_info_var;
                  locals_var = cfg->gsharedvt_locals_var;
                  D.50346 = var->opcode;
                  D.50382 = D.50346 != 331;
                  D.50383 = (long int) D.50382;
                  D.50384 = __builtin_expect (D.50383, 0);
                  if (D.50384 != 0) goto <D.50385>; else goto <D.50386>;
                  <D.50385>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 12938, "var->opcode == OP_GSHAREDVT_LOCAL");
                  <D.50386>:
                  D.50387 = info_var == 0B;
                  D.50388 = (long int) D.50387;
                  D.50389 = __builtin_expect (D.50388, 0);
                  if (D.50389 != 0) goto <D.50390>; else goto <D.50391>;
                  <D.50390>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 12940, "info_var");
                  <D.50391>:
                  D.50392 = locals_var == 0B;
                  D.50393 = (long int) D.50392;
                  D.50394 = __builtin_expect (D.50393, 0);
                  if (D.50394 != 0) goto <D.50395>; else goto <D.50396>;
                  <D.50395>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 12941, "locals_var");
                  <D.50396>:
                  cfg->gsharedvt_locals_var_ins = 0B;
                  D.50397 = info_var->opcode;
                  if (D.50397 == 367) goto <D.50398>; else goto <D.50399>;
                  <D.50398>:
                  D.50400 = alloc_ireg (cfg);
                  reg1 = (int) D.50400;
                  D.50320 = cfg->mempool;
                  load = mono_mempool_alloc (D.50320, 80);
                  load->data.op[1].const_val = 0;
                  D.50401 = load->data.op[1].const_val;
                  load->data.op[0].const_val = D.50401;
                  load->prev = 0B;
                  D.50402 = load->prev;
                  load->next = D.50402;
                  load->opcode = 388;
                  load->flags = 0;
                  load->type = 0;
                  load->dreg = -1;
                  load->sreg3 = -1;
                  D.50403 = load->sreg3;
                  load->sreg2 = D.50403;
                  D.50404 = load->sreg2;
                  load->sreg1 = D.50404;
                  D.50405 = cfg->ip;
                  load->cil_code = D.50405;
                  load->dreg = reg1;
                  D.50406 = info_var->sreg1;
                  load->sreg1 = D.50406;
                  D.50407 = info_var->data.op[0].const_val;
                  load->data.op[0].const_val = D.50407;
                  load->type = 1;
                  goto <D.50408>;
                  <D.50399>:
                  D.50397 = info_var->opcode;
                  if (D.50397 == 366) goto <D.50409>; else goto <D.50410>;
                  <D.50409>:
                  load = 0B;
                  reg1 = info_var->dreg;
                  goto <D.50411>;
                  <D.50410>:
                  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 12954);
                  <D.50411>:
                  <D.50408>:
                  D.50412 = alloc_ireg (cfg);
                  reg2 = (int) D.50412;
                  D.50320 = cfg->mempool;
                  load2 = mono_mempool_alloc (D.50320, 80);
                  load2->data.op[1].const_val = 0;
                  D.50413 = load2->data.op[1].const_val;
                  load2->data.op[0].const_val = D.50413;
                  load2->prev = 0B;
                  D.50414 = load2->prev;
                  load2->next = D.50414;
                  load2->opcode = 393;
                  load2->flags = 0;
                  load2->type = 0;
                  load2->dreg = -1;
                  load2->sreg3 = -1;
                  D.50415 = load2->sreg3;
                  load2->sreg2 = D.50415;
                  D.50416 = load2->sreg2;
                  load2->sreg1 = D.50416;
                  D.50405 = cfg->ip;
                  load2->cil_code = D.50405;
                  load2->dreg = reg2;
                  load2->sreg1 = reg1;
                  D.50417 = (long unsigned int) idx;
                  D.50418 = D.50417 + 1;
                  D.50419 = D.50418 * 8;
                  D.50420 = (long int) D.50419;
                  load2->data.op[0].const_val = D.50420;
                  load2->type = 1;
                  D.50421 = alloc_ireg (cfg);
                  reg3 = (int) D.50421;
                  D.50422 = locals_var->opcode;
                  if (D.50422 == 367) goto <D.50423>; else goto <D.50424>;
                  <D.50423>:
                  D.50320 = cfg->mempool;
                  load3 = mono_mempool_alloc (D.50320, 80);
                  load3->data.op[1].const_val = 0;
                  D.50425 = load3->data.op[1].const_val;
                  load3->data.op[0].const_val = D.50425;
                  load3->prev = 0B;
                  D.50426 = load3->prev;
                  load3->next = D.50426;
                  load3->opcode = 388;
                  load3->flags = 0;
                  load3->type = 0;
                  load3->dreg = -1;
                  load3->sreg3 = -1;
                  D.50427 = load3->sreg3;
                  load3->sreg2 = D.50427;
                  D.50428 = load3->sreg2;
                  load3->sreg1 = D.50428;
                  D.50405 = cfg->ip;
                  load3->cil_code = D.50405;
                  load3->dreg = reg3;
                  D.50429 = locals_var->sreg1;
                  load3->sreg1 = D.50429;
                  D.50430 = locals_var->data.op[0].const_val;
                  load3->data.op[0].const_val = D.50430;
                  load3->type = 1;
                  goto <D.50431>;
                  <D.50424>:
                  D.50422 = locals_var->opcode;
                  if (D.50422 == 366) goto <D.50432>; else goto <D.50433>;
                  <D.50432>:
                  D.50320 = cfg->mempool;
                  load3 = mono_mempool_alloc (D.50320, 80);
                  load3->data.op[1].const_val = 0;
                  D.50425 = load3->data.op[1].const_val;
                  load3->data.op[0].const_val = D.50425;
                  load3->prev = 0B;
                  D.50426 = load3->prev;
                  load3->next = D.50426;
                  load3->opcode = 424;
                  load3->flags = 0;
                  load3->type = 0;
                  load3->dreg = -1;
                  load3->sreg3 = -1;
                  D.50427 = load3->sreg3;
                  load3->sreg2 = D.50427;
                  D.50428 = load3->sreg2;
                  load3->sreg1 = D.50428;
                  D.50405 = cfg->ip;
                  load3->cil_code = D.50405;
                  load3->dreg = reg3;
                  D.50434 = locals_var->dreg;
                  load3->sreg1 = D.50434;
                  goto <D.50435>;
                  <D.50433>:
                  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 12965);
                  <D.50435>:
                  <D.50431>:
                  ins->opcode = 479;
                  ins->sreg1 = reg3;
                  ins->sreg2 = reg2;
                  mono_bblock_insert_before_ins (bb, ins, load3);
                  mono_bblock_insert_before_ins (bb, load3, load2);
                  if (load != 0B) goto <D.50436>; else goto <D.50437>;
                  <D.50436>:
                  mono_bblock_insert_before_ins (bb, load2, load);
                  <D.50437>:
                }
                goto <D.50379>;
                <D.50378>:
                D.50346 = var->opcode;
                D.50438 = D.50346 != 367;
                D.50439 = (long int) D.50438;
                D.50440 = __builtin_expect (D.50439, 0);
                if (D.50440 != 0) goto <D.50441>; else goto <D.50442>;
                <D.50441>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 12977, "var->opcode == OP_REGOFFSET");
                <D.50442>:
                ins->opcode = 429;
                D.50376 = var->sreg1;
                ins->sreg1 = D.50376;
                D.50377 = var->data.op[0].const_val;
                ins->data.op[1].const_val = D.50377;
                <D.50379>:
                <D.50363>:
                <D.50361>:
                *need_local_opts = 1;
                D.50333 = ins->opcode;
                D.50334 = (int) D.50333;
                D.50335 = D.50334 + -313;
                D.50336 = D.50335 * 4;
                spec = &ins_info[D.50336];
              }
              <D.50345>:
              D.50333 = ins->opcode;
              if (D.50333 <= 312) goto <D.50443>; else goto <D.50444>;
              <D.50443>:
              mono_print_ins (ins);
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 12990);
              <D.50444>:
              D.50333 = ins->opcode;
              D.50445 = D.50333 + 65162;
              if (D.50445 <= 13) goto <D.50446>; else goto <D.50447>;
              <D.50446>:
              tmp_reg = ins->dreg;
              D.50448 = ins->sreg2;
              ins->dreg = D.50448;
              ins->sreg2 = tmp_reg;
              store = 1;
              spec2[0] = 32;
              D.50449 = MEM[(const char *)spec + 1B];
              spec2[1] = D.50449;
              D.50450 = *spec;
              spec2[2] = D.50450;
              spec2[3] = 32;
              spec = &spec2;
              goto <D.50451>;
              <D.50447>:
              D.50333 = ins->opcode;
              D.50452 = D.50333 + 65126;
              if (D.50452 <= 6) goto <D.50453>; else goto <D.50454>;
              <D.50453>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 13010);
              <D.50454>:
              store = 0;
              <D.50451>:
              no_lvreg = 0;
              D.50323 = cfg->verbose_level;
              D.50337 = D.50323 > 2;
              D.50338 = (long int) D.50337;
              D.50339 = __builtin_expect (D.50338, 0);
              if (D.50339 != 0) goto <D.50455>; else goto <D.50456>;
              <D.50455>:
              D.50457 = ins->dreg;
              printf ("\t %.3s %d", spec, D.50457);
              D.50458 = ins->sreg1;
              sregs[0] = D.50458;
              D.50448 = ins->sreg2;
              sregs[1] = D.50448;
              D.50459 = ins->sreg3;
              sregs[2] = D.50459;
              D.50333 = ins->opcode;
              D.50334 = (int) D.50333;
              D.50335 = D.50334 + -313;
              D.50460 = ins_sreg_counts[D.50335];
              num_sregs = (int) D.50460;
              srcindex = 0;
              goto <D.28393>;
              <D.28392>:
              D.50461 = sregs[srcindex];
              printf (" %d", D.50461);
              srcindex = srcindex + 1;
              <D.28393>:
              if (srcindex < num_sregs) goto <D.28392>; else goto <D.28394>;
              <D.28394>:
              printf ("\n");
              <D.50456>:
              D.50450 = *spec;
              regtype = (int) D.50450;
              D.50457 = ins->dreg;
              if (D.50457 != -1) goto <D.50463>; else goto <D.50467>;
              <D.50467>:
              if (regtype != 32) goto <D.50463>; else goto <D.50464>;
              <D.50463>:
              D.50457 = ins->dreg;
              if (D.50457 == -1) goto <D.50465>; else goto <D.50468>;
              <D.50468>:
              if (regtype == 32) goto <D.50465>; else goto <D.50464>;
              <D.50465>:
              iftmp.447 = 1;
              goto <D.50466>;
              <D.50464>:
              iftmp.447 = 0;
              <D.50466>:
              D.50469 = iftmp.447 != 0;
              D.50470 = (long int) D.50469;
              D.50471 = __builtin_expect (D.50470, 0);
              if (D.50471 != 0) goto <D.50472>; else goto <D.50473>;
              <D.50472>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13027, "((ins->dreg == -1) && (regtype == \' \')) || ((ins->dreg != -1) && (regtype != \' \'))");
              <D.50473>:
              prev_dreg = -1;
              D.50457 = ins->dreg;
              if (D.50457 != -1) goto <D.50474>; else goto <D.50475>;
              <D.50474>:
              D.50457 = ins->dreg;
              D.50476 = (unsigned int) D.50457;
              D.50477 = cfg->vreg_to_inst_len;
              if (D.50476 < D.50477) goto <D.50478>; else goto <D.50479>;
              <D.50478>:
              D.50480 = cfg->vreg_to_inst;
              D.50457 = ins->dreg;
              D.50481 = (long unsigned int) D.50457;
              D.50482 = D.50481 * 8;
              D.50483 = D.50480 + D.50482;
              D.50484 = *D.50483;
              if (D.50484 != 0B) goto <D.50485>; else goto <D.50486>;
              <D.50485>:
              {
                struct MonoInst * var;
                struct MonoInst * store_ins;
                int store_opcode;
                struct MonoInst * def_ins;
                int dreg;

                D.50457 = ins->dreg;
                D.50476 = (unsigned int) D.50457;
                D.50477 = cfg->vreg_to_inst_len;
                if (D.50476 < D.50477) goto <D.50488>; else goto <D.50489>;
                <D.50488>:
                D.50480 = cfg->vreg_to_inst;
                D.50457 = ins->dreg;
                D.50481 = (long unsigned int) D.50457;
                D.50482 = D.50481 * 8;
                D.50483 = D.50480 + D.50482;
                iftmp.448 = *D.50483;
                goto <D.50490>;
                <D.50489>:
                iftmp.448 = 0B;
                <D.50490>:
                var = iftmp.448;
                def_ins = ins;
                dreg = ins->dreg;
                D.50491 = var->data.op[1].vtype;
                D.50492 = mono_type_to_store_membase (cfg, D.50491);
                store_opcode = (int) D.50492;
                D.50493 = var->opcode;
                if (D.50493 == 366) goto <D.50494>; else goto <D.50495>;
                <D.50494>:
                D.50496 = var->dreg;
                ins->dreg = D.50496;
                goto <D.50497>;
                <D.50495>:
                D.50457 = ins->dreg;
                D.50458 = ins->sreg1;
                if (D.50457 == D.50458) goto <D.50500>; else goto <D.50498>;
                <D.50500>:
                D.50450 = *spec;
                if (D.50450 == 105) goto <D.50501>; else goto <D.50498>;
                <D.50501>:
                D.50502 = spec + 1;
                D.50503 = *D.50502;
                if (D.50503 == 105) goto <D.50504>; else goto <D.50498>;
                <D.50504>:
                D.50457 = ins->dreg;
                D.50481 = (long unsigned int) D.50457;
                D.50505 = D.50481 * 4;
                D.50506 = vreg_to_lvreg + D.50505;
                D.50507 = *D.50506;
                if (D.50507 == 0) goto <D.50508>; else goto <D.50498>;
                <D.50508>:
                D.50333 = ins->opcode;
                D.50334 = (int) D.50333;
                D.50509 = op_to_op_dest_membase (store_opcode, D.50334);
                if (D.50509 != -1) goto <D.50510>; else goto <D.50498>;
                <D.50510>:
                D.50493 = var->opcode;
                D.50511 = D.50493 != 367;
                D.50512 = (long int) D.50511;
                D.50513 = __builtin_expect (D.50512, 0);
                if (D.50513 != 0) goto <D.50514>; else goto <D.50515>;
                <D.50514>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13045, "var->opcode == OP_REGOFFSET");
                <D.50515>:
                D.50333 = ins->opcode;
                if (D.50333 == 424) goto <D.50516>; else goto <D.50517>;
                <D.50516>:
                ins->opcode = 316;
                ins->dreg = -1;
                ins->sreg3 = -1;
                D.50459 = ins->sreg3;
                ins->sreg2 = D.50459;
                D.50448 = ins->sreg2;
                ins->sreg1 = D.50448;
                def_ins = 0B;
                goto <D.50518>;
                <D.50517>:
                D.50333 = ins->opcode;
                D.50334 = (int) D.50333;
                D.50519 = op_to_op_dest_membase (store_opcode, D.50334);
                D.50520 = (short unsigned int) D.50519;
                ins->opcode = D.50520;
                D.50521 = var->sreg1;
                ins->sreg1 = D.50521;
                D.50522 = var->data.op[0].const_val;
                ins->data.op[0].const_val = D.50522;
                ins->dreg = -1;
                <D.50518>:
                D.50333 = ins->opcode;
                D.50334 = (int) D.50333;
                D.50335 = D.50334 + -313;
                D.50336 = D.50335 * 4;
                spec = &ins_info[D.50336];
                goto <D.50499>;
                <D.50498>:
                {
                  guint32 lvreg;

                  D.50493 = var->opcode;
                  D.50511 = D.50493 != 367;
                  D.50512 = (long int) D.50511;
                  D.50513 = __builtin_expect (D.50512, 0);
                  if (D.50513 != 0) goto <D.50523>; else goto <D.50524>;
                  <D.50523>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13059, "var->opcode == OP_REGOFFSET");
                  <D.50524>:
                  prev_dreg = ins->dreg;
                  D.50457 = ins->dreg;
                  D.50481 = (long unsigned int) D.50457;
                  D.50505 = D.50481 * 4;
                  D.50506 = vreg_to_lvreg + D.50505;
                  *D.50506 = 0;
                  lvreg = 0;
                  if (0 != 0) goto <D.50525>; else goto <D.50526>;
                  <D.50525>:
                  regtype = 108;
                  store_opcode = 378;
                  <D.50526>:
                  D.50527 = stacktypes[regtype];
                  D.50528 = alloc_dreg (cfg, D.50527);
                  D.50529 = (int) D.50528;
                  ins->dreg = D.50529;
                  D.50530 = store_opcode == 387;
                  D.50531 = (long int) D.50530;
                  D.50532 = __builtin_expect (D.50531, 0);
                  if (D.50532 != 0) goto <D.50533>; else goto <D.50534>;
                  <D.50533>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13086, "store_opcode != OP_STOREV_MEMBASE");
                  <D.50534>:
                  if (lvreg == 0) goto <D.50538>; else goto <D.50535>;
                  <D.50538>:
                  D.50333 = ins->opcode;
                  if (D.50333 == 362) goto <D.50536>; else goto <D.50539>;
                  <D.50539>:
                  D.50333 = ins->opcode;
                  if (D.50333 == 363) goto <D.50540>; else goto <D.50535>;
                  <D.50540>:
                  D.50541 = ins->data.op[0].const_val;
                  if (D.50541 == 0) goto <D.50536>; else goto <D.50535>;
                  <D.50536>:
                  D.50542 = store_membase_reg_to_store_membase_imm (store_opcode);
                  D.50543 = (short unsigned int) D.50542;
                  ins->opcode = D.50543;
                  D.50541 = ins->data.op[0].const_val;
                  ins->data.op[1].const_val = D.50541;
                  D.50521 = var->sreg1;
                  ins->dreg = D.50521;
                  D.50522 = var->data.op[0].const_val;
                  ins->data.op[0].const_val = D.50522;
                  D.50333 = ins->opcode;
                  D.50334 = (int) D.50333;
                  D.50335 = D.50334 + -313;
                  D.50336 = D.50335 * 4;
                  spec = &ins_info[D.50336];
                  goto <D.50537>;
                  <D.50535>:
                  if (lvreg == 0) goto <D.50547>; else goto <D.50544>;
                  <D.50547>:
                  D.50333 = ins->opcode;
                  if (D.50333 == 424) goto <D.50545>; else goto <D.50548>;
                  <D.50548>:
                  D.50333 = ins->opcode;
                  if (D.50333 == 426) goto <D.50545>; else goto <D.50549>;
                  <D.50549>:
                  D.50333 = ins->opcode;
                  if (D.50333 == 425) goto <D.50545>; else goto <D.50544>;
                  <D.50545>:
                  D.50550 = (short unsigned int) store_opcode;
                  ins->opcode = D.50550;
                  D.50521 = var->sreg1;
                  ins->dreg = D.50521;
                  D.50522 = var->data.op[0].const_val;
                  ins->data.op[0].const_val = D.50522;
                  no_lvreg = 1;
                  tmp_reg = ins->dreg;
                  D.50448 = ins->sreg2;
                  ins->dreg = D.50448;
                  ins->sreg2 = tmp_reg;
                  store = 1;
                  spec2[0] = 32;
                  D.50449 = MEM[(const char *)spec + 1B];
                  spec2[1] = D.50449;
                  D.50450 = *spec;
                  spec2[2] = D.50450;
                  spec2[3] = 32;
                  spec = &spec2;
                  goto <D.50546>;
                  <D.50544>:
                  if (lvreg == 0) goto <D.50553>; else goto <D.50551>;
                  <D.50553>:
                  D.50333 = ins->opcode;
                  D.50334 = (int) D.50333;
                  D.50554 = op_to_op_store_membase (store_opcode, D.50334);
                  if (D.50554 != -1) goto <D.50555>; else goto <D.50551>;
                  <D.50555>:
                  D.50333 = ins->opcode;
                  D.50334 = (int) D.50333;
                  D.50556 = op_to_op_store_membase (store_opcode, D.50334);
                  D.50557 = (short unsigned int) D.50556;
                  ins->opcode = D.50557;
                  ins->dreg = -1;
                  D.50521 = var->sreg1;
                  ins->sreg1 = D.50521;
                  D.50522 = var->data.op[0].const_val;
                  ins->data.op[0].const_val = D.50522;
                  D.50333 = ins->opcode;
                  D.50334 = (int) D.50333;
                  D.50335 = D.50334 + -313;
                  D.50336 = D.50335 * 4;
                  spec = &ins_info[D.50336];
                  goto <D.50552>;
                  <D.50551>:
                  D.50320 = cfg->mempool;
                  store_ins = mono_mempool_alloc (D.50320, 80);
                  store_ins->data.op[1].const_val = 0;
                  D.50558 = store_ins->data.op[1].const_val;
                  store_ins->data.op[0].const_val = D.50558;
                  store_ins->prev = 0B;
                  D.50559 = store_ins->prev;
                  store_ins->next = D.50559;
                  D.50550 = (short unsigned int) store_opcode;
                  store_ins->opcode = D.50550;
                  store_ins->flags = 0;
                  store_ins->type = 0;
                  store_ins->dreg = -1;
                  store_ins->sreg3 = -1;
                  D.50560 = store_ins->sreg3;
                  store_ins->sreg2 = D.50560;
                  D.50561 = store_ins->sreg2;
                  store_ins->sreg1 = D.50561;
                  D.50405 = cfg->ip;
                  store_ins->cil_code = D.50405;
                  D.50457 = ins->dreg;
                  store_ins->sreg1 = D.50457;
                  D.50521 = var->sreg1;
                  store_ins->dreg = D.50521;
                  D.50522 = var->data.op[0].const_val;
                  store_ins->data.op[0].const_val = D.50522;
                  mono_bblock_insert_after_ins (bb, ins, store_ins);
                  def_ins = store_ins;
                  D.50562 = var->flags;
                  D.50563 = (int) D.50562;
                  D.50564 = D.50563 & 20;
                  if (D.50564 == 0) goto <D.50565>; else goto <D.50566>;
                  <D.50565>:
                  dest_has_lvreg = 1;
                  <D.50566>:
                  <D.50552>:
                  <D.50546>:
                  <D.50537>:
                }
                <D.50499>:
                <D.50497>:
                if (def_ins != 0B) goto <D.50567>; else goto <D.50568>;
                <D.50567>:
                D.50569 = (long unsigned int) dreg;
                D.50570 = D.50569 * 8;
                D.50571 = live_range_start + D.50570;
                D.50572 = *D.50571;
                if (D.50572 == 0B) goto <D.50573>; else goto <D.50574>;
                <D.50573>:
                D.50569 = (long unsigned int) dreg;
                D.50570 = D.50569 * 8;
                D.50571 = live_range_start + D.50570;
                *D.50571 = def_ins;
                D.50569 = (long unsigned int) dreg;
                D.50570 = D.50569 * 8;
                D.50575 = live_range_start_bb + D.50570;
                *D.50575 = bb;
                <D.50574>:
                <D.50568>:
                D.50286 = BIT_FIELD_REF <*cfg, 64, 5632>;
                D.50287 = D.50286 & 72057594037927936;
                if (D.50287 != 0) goto <D.50576>; else goto <D.50577>;
                <D.50576>:
                if (def_ins != 0B) goto <D.50578>; else goto <D.50579>;
                <D.50578>:
                D.50562 = var->flags;
                D.50580 = (signed char) D.50562;
                if (D.50580 < 0) goto <D.50581>; else goto <D.50582>;
                <D.50581>:
                {
                  struct MonoInst * tmp;

                  D.50320 = cfg->mempool;
                  tmp = mono_mempool_alloc (D.50320, 80);
                  tmp->data.op[1].const_val = 0;
                  D.50583 = tmp->data.op[1].const_val;
                  tmp->data.op[0].const_val = D.50583;
                  tmp->prev = 0B;
                  D.50584 = tmp->prev;
                  tmp->next = D.50584;
                  tmp->opcode = 838;
                  tmp->flags = 0;
                  tmp->type = 0;
                  tmp->dreg = -1;
                  tmp->sreg3 = -1;
                  D.50585 = tmp->sreg3;
                  tmp->sreg2 = D.50585;
                  D.50586 = tmp->sreg2;
                  tmp->sreg1 = D.50586;
                  D.50405 = cfg->ip;
                  tmp->cil_code = D.50405;
                  D.50587 = (long int) dreg;
                  tmp->data.op[1].const_val = D.50587;
                  mono_bblock_insert_after_ins (bb, def_ins, tmp);
                }
                <D.50582>:
                <D.50579>:
                <D.50577>:
              }
              <D.50486>:
              <D.50479>:
              <D.50475>:
              D.50458 = ins->sreg1;
              sregs[0] = D.50458;
              D.50448 = ins->sreg2;
              sregs[1] = D.50448;
              D.50459 = ins->sreg3;
              sregs[2] = D.50459;
              D.50333 = ins->opcode;
              D.50334 = (int) D.50333;
              D.50335 = D.50334 + -313;
              D.50460 = ins_sreg_counts[D.50335];
              num_sregs = (int) D.50460;
              srcindex = 0;
              goto <D.28410>;
              <D.28409>:
              D.50588 = srcindex + 1;
              D.50589 = (sizetype) D.50588;
              D.50590 = spec + D.50589;
              D.50591 = *D.50590;
              regtype = (int) D.50591;
              sreg = sregs[srcindex];
              if (sreg != -1) goto <D.50593>; else goto <D.50597>;
              <D.50597>:
              if (regtype != 32) goto <D.50593>; else goto <D.50594>;
              <D.50593>:
              if (sreg == -1) goto <D.50595>; else goto <D.50598>;
              <D.50598>:
              if (regtype == 32) goto <D.50595>; else goto <D.50594>;
              <D.50595>:
              iftmp.449 = 1;
              goto <D.50596>;
              <D.50594>:
              iftmp.449 = 0;
              <D.50596>:
              D.50599 = iftmp.449 != 0;
              D.50600 = (long int) D.50599;
              D.50601 = __builtin_expect (D.50600, 0);
              if (D.50601 != 0) goto <D.50602>; else goto <D.50603>;
              <D.50602>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13163, "((sreg == -1) && (regtype == \' \')) || ((sreg != -1) && (regtype != \' \'))");
              <D.50603>:
              if (sreg != -1) goto <D.50604>; else goto <D.50605>;
              <D.50604>:
              D.50477 = cfg->vreg_to_inst_len;
              sreg.450 = (unsigned int) sreg;
              if (D.50477 > sreg.450) goto <D.50607>; else goto <D.50608>;
              <D.50607>:
              D.50480 = cfg->vreg_to_inst;
              D.50609 = (long unsigned int) sreg;
              D.50610 = D.50609 * 8;
              D.50611 = D.50480 + D.50610;
              D.50612 = *D.50611;
              if (D.50612 != 0B) goto <D.50613>; else goto <D.50614>;
              <D.50613>:
              {
                struct MonoInst * var;
                struct MonoInst * use_ins;
                struct MonoInst * load_ins;
                guint32 load_opcode;

                D.50477 = cfg->vreg_to_inst_len;
                sreg.450 = (unsigned int) sreg;
                if (D.50477 > sreg.450) goto <D.50616>; else goto <D.50617>;
                <D.50616>:
                D.50480 = cfg->vreg_to_inst;
                D.50609 = (long unsigned int) sreg;
                D.50610 = D.50609 * 8;
                D.50611 = D.50480 + D.50610;
                iftmp.451 = *D.50611;
                goto <D.50618>;
                <D.50617>:
                iftmp.451 = 0B;
                <D.50618>:
                var = iftmp.451;
                use_ins = ins;
                D.50619 = var->opcode;
                if (D.50619 == 366) goto <D.50620>; else goto <D.50621>;
                <D.50620>:
                D.50622 = var->dreg;
                sregs[srcindex] = D.50622;
                D.50609 = (long unsigned int) sreg;
                D.50610 = D.50609 * 8;
                D.50623 = live_range_end + D.50610;
                *D.50623 = use_ins;
                D.50609 = (long unsigned int) sreg;
                D.50610 = D.50609 * 8;
                D.50624 = live_range_end_bb + D.50610;
                *D.50624 = bb;
                D.50286 = BIT_FIELD_REF <*cfg, 64, 5632>;
                D.50287 = D.50286 & 72057594037927936;
                if (D.50287 != 0) goto <D.50625>; else goto <D.50626>;
                <D.50625>:
                D.50622 = var->dreg;
                if (D.50622 < orig_next_vreg) goto <D.50627>; else goto <D.50628>;
                <D.50627>:
                D.50629 = var->flags;
                D.50630 = (signed char) D.50629;
                if (D.50630 < 0) goto <D.50631>; else goto <D.50632>;
                <D.50631>:
                {
                  struct MonoInst * tmp;

                  D.50320 = cfg->mempool;
                  tmp = mono_mempool_alloc (D.50320, 80);
                  tmp->data.op[1].const_val = 0;
                  D.50633 = tmp->data.op[1].const_val;
                  tmp->data.op[0].const_val = D.50633;
                  tmp->prev = 0B;
                  D.50634 = tmp->prev;
                  tmp->next = D.50634;
                  tmp->opcode = 839;
                  tmp->flags = 0;
                  tmp->type = 0;
                  tmp->dreg = -1;
                  tmp->sreg3 = -1;
                  D.50635 = tmp->sreg3;
                  tmp->sreg2 = D.50635;
                  D.50636 = tmp->sreg2;
                  tmp->sreg1 = D.50636;
                  D.50405 = cfg->ip;
                  tmp->cil_code = D.50405;
                  D.50637 = (long int) sreg;
                  tmp->data.op[1].const_val = D.50637;
                  mono_bblock_insert_after_ins (bb, ins, tmp);
                }
                <D.50632>:
                <D.50628>:
                <D.50626>:
                // predicted unlikely by continue predictor.
                goto <D.28407>;
                <D.50621>:
                D.50619 = var->opcode;
                D.50638 = D.50619 != 367;
                D.50639 = (long int) D.50638;
                D.50640 = __builtin_expect (D.50639, 0);
                if (D.50640 != 0) goto <D.50641>; else goto <D.50642>;
                <D.50641>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13188, "var->opcode == OP_REGOFFSET");
                <D.50642>:
                D.50643 = var->data.op[1].vtype;
                load_opcode = mono_type_to_load_membase (cfg, D.50643);
                D.50644 = load_opcode == 399;
                D.50645 = (long int) D.50644;
                D.50646 = __builtin_expect (D.50645, 0);
                if (D.50646 != 0) goto <D.50647>; else goto <D.50648>;
                <D.50647>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13192, "load_opcode != OP_LOADV_MEMBASE");
                <D.50648>:
                D.50609 = (long unsigned int) sreg;
                D.50649 = D.50609 * 4;
                D.50650 = vreg_to_lvreg + D.50649;
                D.50651 = *D.50650;
                if (D.50651 != 0) goto <D.50652>; else goto <D.50653>;
                <D.50652>:
                D.50609 = (long unsigned int) sreg;
                D.50649 = D.50609 * 4;
                D.50650 = vreg_to_lvreg + D.50649;
                D.50651 = *D.50650;
                D.50654 = D.50651 == 4294967295;
                D.50655 = (long int) D.50654;
                D.50656 = __builtin_expect (D.50655, 0);
                if (D.50656 != 0) goto <D.50657>; else goto <D.50658>;
                <D.50657>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13195, "vreg_to_lvreg [sreg] != -1");
                <D.50658>:
                D.50323 = cfg->verbose_level;
                D.50337 = D.50323 > 2;
                D.50338 = (long int) D.50337;
                D.50339 = __builtin_expect (D.50338, 0);
                if (D.50339 != 0) goto <D.50659>; else goto <D.50660>;
                <D.50659>:
                D.50609 = (long unsigned int) sreg;
                D.50649 = D.50609 * 4;
                D.50650 = vreg_to_lvreg + D.50649;
                D.50651 = *D.50650;
                printf ("\t\tUse lvreg R%d for R%d.\n", D.50651, sreg);
                <D.50660>:
                D.50609 = (long unsigned int) sreg;
                D.50649 = D.50609 * 4;
                D.50650 = vreg_to_lvreg + D.50649;
                D.50651 = *D.50650;
                D.50661 = (int) D.50651;
                sregs[srcindex] = D.50661;
                // predicted unlikely by continue predictor.
                goto <D.28407>;
                <D.50653>:
                if (srcindex == 0) goto <D.50664>; else goto <D.50662>;
                <D.50664>:
                load_opcode.452 = (int) load_opcode;
                D.50333 = ins->opcode;
                D.50334 = (int) D.50333;
                D.50666 = op_to_op_src1_membase (load_opcode.452, D.50334);
                if (D.50666 != -1) goto <D.50667>; else goto <D.50662>;
                <D.50667>:
                load_opcode.452 = (int) load_opcode;
                D.50333 = ins->opcode;
                D.50334 = (int) D.50333;
                D.50668 = op_to_op_src1_membase (load_opcode.452, D.50334);
                D.50669 = (short unsigned int) D.50668;
                ins->opcode = D.50669;
                D.50670 = var->sreg1;
                sregs[0] = D.50670;
                D.50671 = var->data.op[0].const_val;
                ins->data.op[0].const_val = D.50671;
                goto <D.50663>;
                <D.50662>:
                if (srcindex == 1) goto <D.50674>; else goto <D.50672>;
                <D.50674>:
                load_opcode.452 = (int) load_opcode;
                D.50333 = ins->opcode;
                D.50334 = (int) D.50333;
                D.50675 = op_to_op_src2_membase (load_opcode.452, D.50334);
                if (D.50675 != -1) goto <D.50676>; else goto <D.50672>;
                <D.50676>:
                load_opcode.452 = (int) load_opcode;
                D.50333 = ins->opcode;
                D.50334 = (int) D.50333;
                D.50677 = op_to_op_src2_membase (load_opcode.452, D.50334);
                D.50678 = (short unsigned int) D.50677;
                ins->opcode = D.50678;
                D.50670 = var->sreg1;
                sregs[1] = D.50670;
                D.50671 = var->data.op[0].const_val;
                ins->data.op[0].const_val = D.50671;
                goto <D.50673>;
                <D.50672>:
                D.50333 = ins->opcode;
                if (D.50333 == 424) goto <D.50679>; else goto <D.50682>;
                <D.50682>:
                D.50333 = ins->opcode;
                if (D.50333 == 426) goto <D.50679>; else goto <D.50680>;
                <D.50679>:
                ins->opcode = 316;
                sreg = ins->dreg;
                goto <D.50681>;
                <D.50680>:
                D.50527 = stacktypes[regtype];
                D.50683 = alloc_dreg (cfg, D.50527);
                sreg = (int) D.50683;
                D.50629 = var->flags;
                D.50684 = (int) D.50629;
                D.50685 = D.50684 & 20;
                if (D.50685 == 0) goto <D.50686>; else goto <D.50687>;
                <D.50686>:
                if (no_lvreg == 0) goto <D.50688>; else goto <D.50689>;
                <D.50688>:
                D.50622 = var->dreg;
                if (D.50622 == prev_dreg) goto <D.50690>; else goto <D.50691>;
                <D.50690>:
                sreg = ins->dreg;
                <D.50691>:
                D.50692 = sreg == -1;
                D.50693 = (long int) D.50692;
                D.50694 = __builtin_expect (D.50693, 0);
                if (D.50694 != 0) goto <D.50695>; else goto <D.50696>;
                <D.50695>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13234, "sreg != -1");
                <D.50696>:
                D.50622 = var->dreg;
                D.50697 = (long unsigned int) D.50622;
                D.50698 = D.50697 * 4;
                D.50699 = vreg_to_lvreg + D.50698;
                sreg.450 = (unsigned int) sreg;
                *D.50699 = sreg.450;
                D.50700 = lvregs_len > 1023;
                D.50701 = (long int) D.50700;
                D.50702 = __builtin_expect (D.50701, 0);
                if (D.50702 != 0) goto <D.50703>; else goto <D.50704>;
                <D.50703>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13236, "lvregs_len < 1024");
                <D.50704>:
                lvregs_len.453 = lvregs_len;
                lvregs_len = lvregs_len.453 + 1;
                D.50706 = (long unsigned int) lvregs_len.453;
                D.50707 = D.50706 * 4;
                D.50708 = lvregs + D.50707;
                D.50622 = var->dreg;
                D.50709 = (unsigned int) D.50622;
                *D.50708 = D.50709;
                <D.50689>:
                <D.50687>:
                <D.50681>:
                sregs[srcindex] = sreg;
                D.50320 = cfg->mempool;
                load_ins = mono_mempool_alloc (D.50320, 80);
                load_ins->data.op[1].const_val = 0;
                D.50710 = load_ins->data.op[1].const_val;
                load_ins->data.op[0].const_val = D.50710;
                load_ins->prev = 0B;
                D.50711 = load_ins->prev;
                load_ins->next = D.50711;
                D.50712 = (short unsigned int) load_opcode;
                load_ins->opcode = D.50712;
                load_ins->flags = 0;
                load_ins->type = 0;
                load_ins->dreg = -1;
                load_ins->sreg3 = -1;
                D.50713 = load_ins->sreg3;
                load_ins->sreg2 = D.50713;
                D.50714 = load_ins->sreg2;
                load_ins->sreg1 = D.50714;
                D.50405 = cfg->ip;
                load_ins->cil_code = D.50405;
                load_ins->dreg = sreg;
                D.50670 = var->sreg1;
                load_ins->sreg1 = D.50670;
                D.50671 = var->data.op[0].const_val;
                load_ins->data.op[0].const_val = D.50671;
                load_ins->type = 1;
                mono_bblock_insert_before_ins (bb, ins, load_ins);
                use_ins = load_ins;
                <D.50673>:
                <D.50663>:
                D.50622 = var->dreg;
                if (D.50622 < orig_next_vreg) goto <D.50715>; else goto <D.50716>;
                <D.50715>:
                D.50622 = var->dreg;
                D.50697 = (long unsigned int) D.50622;
                D.50717 = D.50697 * 8;
                D.50718 = live_range_end + D.50717;
                *D.50718 = use_ins;
                D.50622 = var->dreg;
                D.50697 = (long unsigned int) D.50622;
                D.50717 = D.50697 * 8;
                D.50719 = live_range_end_bb + D.50717;
                *D.50719 = bb;
                <D.50716>:
                D.50286 = BIT_FIELD_REF <*cfg, 64, 5632>;
                D.50287 = D.50286 & 72057594037927936;
                if (D.50287 != 0) goto <D.50720>; else goto <D.50721>;
                <D.50720>:
                D.50622 = var->dreg;
                if (D.50622 < orig_next_vreg) goto <D.50722>; else goto <D.50723>;
                <D.50722>:
                D.50629 = var->flags;
                D.50630 = (signed char) D.50629;
                if (D.50630 < 0) goto <D.50724>; else goto <D.50725>;
                <D.50724>:
                {
                  struct MonoInst * tmp;

                  D.50320 = cfg->mempool;
                  tmp = mono_mempool_alloc (D.50320, 80);
                  tmp->data.op[1].const_val = 0;
                  D.50726 = tmp->data.op[1].const_val;
                  tmp->data.op[0].const_val = D.50726;
                  tmp->prev = 0B;
                  D.50727 = tmp->prev;
                  tmp->next = D.50727;
                  tmp->opcode = 839;
                  tmp->flags = 0;
                  tmp->type = 0;
                  tmp->dreg = -1;
                  tmp->sreg3 = -1;
                  D.50728 = tmp->sreg3;
                  tmp->sreg2 = D.50728;
                  D.50729 = tmp->sreg2;
                  tmp->sreg1 = D.50729;
                  D.50405 = cfg->ip;
                  tmp->cil_code = D.50405;
                  D.50622 = var->dreg;
                  D.50730 = (long int) D.50622;
                  tmp->data.op[1].const_val = D.50730;
                  mono_bblock_insert_after_ins (bb, ins, tmp);
                }
                <D.50725>:
                <D.50723>:
                <D.50721>:
              }
              <D.50614>:
              <D.50608>:
              <D.50605>:
              <D.28407>:
              srcindex = srcindex + 1;
              <D.28410>:
              if (srcindex <= 2) goto <D.28409>; else goto <D.28411>;
              <D.28411>:
              mono_inst_set_src_registers (ins, &sregs);
              if (dest_has_lvreg != 0) goto <D.50731>; else goto <D.50732>;
              <D.50731>:
              D.50457 = ins->dreg;
              D.50733 = D.50457 == -1;
              D.50734 = (long int) D.50733;
              D.50735 = __builtin_expect (D.50734, 0);
              if (D.50735 != 0) goto <D.50736>; else goto <D.50737>;
              <D.50736>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13281, "ins->dreg != -1");
              <D.50737>:
              D.50738 = (long unsigned int) prev_dreg;
              D.50739 = D.50738 * 4;
              D.50740 = vreg_to_lvreg + D.50739;
              D.50457 = ins->dreg;
              D.50476 = (unsigned int) D.50457;
              *D.50740 = D.50476;
              D.50700 = lvregs_len > 1023;
              D.50701 = (long int) D.50700;
              D.50702 = __builtin_expect (D.50701, 0);
              if (D.50702 != 0) goto <D.50741>; else goto <D.50742>;
              <D.50741>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "method-to-ir.c", 13283, "lvregs_len < 1024");
              <D.50742>:
              lvregs_len.454 = lvregs_len;
              lvregs_len = lvregs_len.454 + 1;
              D.50744 = (long unsigned int) lvregs_len.454;
              D.50745 = D.50744 * 4;
              D.50746 = lvregs + D.50745;
              prev_dreg.455 = (unsigned int) prev_dreg;
              *D.50746 = prev_dreg.455;
              dest_has_lvreg = 0;
              <D.50732>:
              if (store != 0) goto <D.50748>; else goto <D.50749>;
              <D.50748>:
              tmp_reg = ins->dreg;
              D.50448 = ins->sreg2;
              ins->dreg = D.50448;
              ins->sreg2 = tmp_reg;
              <D.50749>:
              D.50333 = ins->opcode;
              D.50753 = D.50333 + 65193;
              if (D.50753 <= 2) goto <D.50750>; else goto <D.50754>;
              <D.50754>:
              D.50333 = ins->opcode;
              D.50755 = D.50333 + 65187;
              if (D.50755 <= 2) goto <D.50750>; else goto <D.50756>;
              <D.50756>:
              D.50333 = ins->opcode;
              D.50757 = D.50333 + 65184;
              if (D.50757 <= 2) goto <D.50750>; else goto <D.50758>;
              <D.50758>:
              D.50333 = ins->opcode;
              D.50759 = D.50333 + 65181;
              if (D.50759 <= 2) goto <D.50750>; else goto <D.50760>;
              <D.50760>:
              D.50333 = ins->opcode;
              D.50761 = D.50333 + 65190;
              if (D.50761 <= 2) goto <D.50750>; else goto <D.50762>;
              <D.50762>:
              D.50333 = ins->opcode;
              D.50763 = D.50333 + 65178;
              if (D.50763 <= 2) goto <D.50750>; else goto <D.50764>;
              <D.50764>:
              D.50333 = ins->opcode;
              if (D.50333 == 444) goto <D.50750>; else goto <D.50751>;
              <D.50750>:
              i = 0;
              goto <D.28413>;
              <D.28412>:
              D.50291 = (long unsigned int) i;
              D.50327 = D.50291 * 4;
              D.50328 = lvregs + D.50327;
              D.50329 = *D.50328;
              D.50330 = (long unsigned int) D.50329;
              D.50331 = D.50330 * 4;
              D.50332 = vreg_to_lvreg + D.50331;
              *D.50332 = 0;
              i = i + 1;
              <D.28413>:
              if (i < lvregs_len) goto <D.28412>; else goto <D.28414>;
              <D.28414>:
              lvregs_len = 0;
              goto <D.50752>;
              <D.50751>:
              D.50333 = ins->opcode;
              if (D.50333 == 316) goto <D.50765>; else goto <D.50766>;
              <D.50765>:
              ins->dreg = -1;
              ins->sreg3 = -1;
              D.50459 = ins->sreg3;
              ins->sreg2 = D.50459;
              D.50448 = ins->sreg2;
              ins->sreg1 = D.50448;
              <D.50766>:
              <D.50752>:
              D.50323 = cfg->verbose_level;
              if (D.50323 > 2) goto <D.50767>; else goto <D.50768>;
              <D.50767>:
              mono_print_ins_index (1, ins);
              <D.50768>:
            }
          finally
            {
              sregs = {CLOBBER};
            }
        }
        <D.28380>:
        ins = ins->next;
        <D.28416>:
        if (ins != 0B) goto <D.28415>; else goto <D.28417>;
        <D.28417>:
        D.50769 = BIT_FIELD_REF <*cfg, 64, 5568>;
        D.50770 = D.50769 & 1;
        if (D.50770 != 0) goto <D.50771>; else goto <D.50772>;
        <D.50771>:
        D.50773 = bb->live_out_set;
        if (D.50773 != 0B) goto <D.50774>; else goto <D.50775>;
        <D.50774>:
        D.50776 = bb->code;
        if (D.50776 != 0B) goto <D.50777>; else goto <D.50778>;
        <D.50777>:
        i = 0;
        goto <D.28421>;
        <D.28420>:
        {
          struct MonoMethodVar * vi;

          D.50779 = cfg->vars;
          D.50291 = (long unsigned int) i;
          D.50780 = D.50291 * 80;
          vi = D.50779 + D.50780;
          D.50784 = vi->vreg;
          D.50785 = (unsigned int) D.50784;
          D.50477 = cfg->vreg_to_inst_len;
          if (D.50785 < D.50477) goto <D.50786>; else goto <D.50782>;
          <D.50786>:
          D.50480 = cfg->vreg_to_inst;
          D.50784 = vi->vreg;
          D.50787 = (long unsigned int) D.50784;
          D.50788 = D.50787 * 8;
          D.50789 = D.50480 + D.50788;
          D.50790 = *D.50789;
          if (D.50790 != 0B) goto <D.50791>; else goto <D.50782>;
          <D.50791>:
          D.50784 = vi->vreg;
          D.50785 = (unsigned int) D.50784;
          D.50477 = cfg->vreg_to_inst_len;
          if (D.50785 < D.50477) goto <D.50793>; else goto <D.50794>;
          <D.50793>:
          D.50480 = cfg->vreg_to_inst;
          D.50784 = vi->vreg;
          D.50787 = (long unsigned int) D.50784;
          D.50788 = D.50787 * 8;
          D.50789 = D.50480 + D.50788;
          iftmp.457 = *D.50789;
          goto <D.50795>;
          <D.50794>:
          iftmp.457 = 0B;
          <D.50795>:
          D.50796 = iftmp.457->flags;
          D.50797 = (int) D.50796;
          D.50798 = D.50797 & 20;
          if (D.50798 != 0) goto <D.50799>; else goto <D.50782>;
          <D.50799>:
          iftmp.456 = 1;
          goto <D.50783>;
          <D.50782>:
          iftmp.456 = 0;
          <D.50783>:
          D.50800 = iftmp.456 != 0;
          D.50801 = (long int) D.50800;
          D.50802 = __builtin_expect (D.50801, 0);
          if (D.50802 != 0) goto <D.50803>; else goto <D.50804>;
          <D.50803>:
          // predicted unlikely by continue predictor.
          goto <D.28419>;
          <D.50804>:
          D.50805 = bb->live_in_set;
          D.50806 = i / 64;
          D.50807 = (long unsigned int) D.50806;
          D.50808 = D.50805->data[D.50807];
          D.50809 = i & 63;
          D.50810 = D.50808 >> D.50809;
          D.50811 = D.50810 & 1;
          if (D.50811 != 0) goto <D.50812>; else goto <D.50813>;
          <D.50812>:
          D.50784 = vi->vreg;
          D.50787 = (long unsigned int) D.50784;
          D.50788 = D.50787 * 8;
          D.50814 = live_range_start + D.50788;
          D.50815 = *D.50814;
          if (D.50815 == 0B) goto <D.50816>; else goto <D.50817>;
          <D.50816>:
          D.50784 = vi->vreg;
          D.50787 = (long unsigned int) D.50784;
          D.50788 = D.50787 * 8;
          D.50814 = live_range_start + D.50788;
          D.50776 = bb->code;
          *D.50814 = D.50776;
          D.50784 = vi->vreg;
          D.50787 = (long unsigned int) D.50784;
          D.50788 = D.50787 * 8;
          D.50818 = live_range_start_bb + D.50788;
          *D.50818 = bb;
          <D.50817>:
          <D.50813>:
          D.50773 = bb->live_out_set;
          D.50806 = i / 64;
          D.50807 = (long unsigned int) D.50806;
          D.50819 = D.50773->data[D.50807];
          D.50809 = i & 63;
          D.50820 = D.50819 >> D.50809;
          D.50821 = D.50820 & 1;
          if (D.50821 != 0) goto <D.50822>; else goto <D.50823>;
          <D.50822>:
          D.50784 = vi->vreg;
          D.50787 = (long unsigned int) D.50784;
          D.50788 = D.50787 * 8;
          D.50824 = live_range_end + D.50788;
          D.50825 = bb->last_ins;
          *D.50824 = D.50825;
          D.50784 = vi->vreg;
          D.50787 = (long unsigned int) D.50784;
          D.50788 = D.50787 * 8;
          D.50826 = live_range_end_bb + D.50788;
          *D.50826 = bb;
          <D.50823>:
        }
        <D.28419>:
        i = i + 1;
        <D.28421>:
        D.50299 = cfg->num_varinfo;
        if (D.50299 > i) goto <D.28420>; else goto <D.28422>;
        <D.28422>:
        <D.50778>:
        <D.50775>:
        <D.50772>:
      }
      bb = bb->next_bb;
      <D.28424>:
      if (bb != 0B) goto <D.28423>; else goto <D.28425>;
      <D.28425>:
      D.50827 = cfg->gsharedvt_locals_var_ins;
      if (D.50827 != 0B) goto <D.50828>; else goto <D.50829>;
      <D.50828>:
      D.50827 = cfg->gsharedvt_locals_var_ins;
      D.50827->opcode = 363;
      D.50827 = cfg->gsharedvt_locals_var_ins;
      D.50827->data.op[1].const_val = 0;
      <D.50829>:
      monoeg_g_free (live_range_start);
      monoeg_g_free (live_range_end);
      monoeg_g_free (live_range_start_bb);
      monoeg_g_free (live_range_end_bb);
    }
  finally
    {
      spec2 = {CLOBBER};
      stacktypes = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.50832;
  long unsigned int D.50833;

  D.50833 = __builtin_object_size (__dest, 0);
  D.50832 = __builtin___memset_chk (__dest, __ch, __len, D.50833);
  return D.50832;
}


op_to_op_dest_membase (int store_opcode, int opcode)
{
  int D.50835;

  D.50835 = -1;
  return D.50835;
}


store_membase_reg_to_store_membase_imm (int opcode)
{
  int D.50837;

  switch (opcode) <default: <D.28205>, case 374: <D.28200>, case 375: <D.28201>, case 376: <D.28202>, case 377: <D.28203>, case 378: <D.28204>>
  <D.28200>:
  D.50837 = 381;
  return D.50837;
  <D.28201>:
  D.50837 = 382;
  return D.50837;
  <D.28202>:
  D.50837 = 383;
  return D.50837;
  <D.28203>:
  D.50837 = 384;
  return D.50837;
  <D.28204>:
  D.50837 = 385;
  return D.50837;
  <D.28205>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "method-to-ir.c", 12041);
  D.50837 = -1;
  return D.50837;
}


op_to_op_store_membase (int store_opcode, int opcode)
{
  int D.50839;

  D.50839 = -1;
  return D.50839;
}


op_to_op_src1_membase (int load_opcode, int opcode)
{
  int D.50841;

  D.50841 = -1;
  return D.50841;
}


op_to_op_src2_membase (int load_opcode, int opcode)
{
  int D.50843;

  D.50843 = -1;
  return D.50843;
}